projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Preserve machine dependent section header flags when reading ELF object file.
[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
46f5aac8
KH		 623 /* Assume we're not going to change any sizes, and we'll only need
624 one pass. */
748abff6
RH		 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
fa152c49
JW		 949 return true;
950}
951
952/* Convert IA-64 specific section flags to bfd internal section flags. */
953
954/* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
955 flag. */
956
957static boolean
958elf64_ia64_section_flags (flags, hdr)
959 flagword *flags;
960 Elf64_Internal_Shdr *hdr;
961{
800eeca4 962 if (hdr->sh_flags & SHF_IA_64_SHORT)
fa152c49 963 *flags |= SEC_SMALL_DATA;
800eeca4
JW		 964
965 return true;
966}
967
968/* Set the correct type for an IA-64 ELF section. We do this by the
969 section name, which is a hack, but ought to work. */
970
971static boolean
972elf64_ia64_fake_sections (abfd, hdr, sec)
973 bfd *abfd;
974 Elf64_Internal_Shdr *hdr;
975 asection *sec;
976{
977 register const char *name;
978
979 name = bfd_get_section_name (abfd, sec);
980
981 if (strcmp (name, ELF_STRING_ia64_unwind) == 0)
982 hdr->sh_type = SHT_IA_64_UNWIND;
983 else if (strcmp (name, ELF_STRING_ia64_archext) == 0)
984 hdr->sh_type = SHT_IA_64_EXT;
985 else if (strcmp (name, ".reloc") == 0)
986 /*
987 * This is an ugly, but unfortunately necessary hack that is
988 * needed when producing EFI binaries on IA-64. It tells
989 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
990 * containing ELF relocation info. We need this hack in order to
991 * be able to generate ELF binaries that can be translated into
992 * EFI applications (which are essentially COFF objects). Those
993 * files contain a COFF ".reloc" section inside an ELF64 object,
994 * which would normally cause BFD to segfault because it would
995 * attempt to interpret this section as containing relocation
996 * entries for section "oc". With this hack enabled, ".reloc"
997 * will be treated as a normal data section, which will avoid the
998 * segfault. However, you won't be able to create an ELF64 binary
999 * with a section named "oc" that needs relocations, but that's
1000 * the kind of ugly side-effects you get when detecting section
1001 * types based on their names... In practice, this limitation is
1002 * unlikely to bite.
1003 */
1004 hdr->sh_type = SHT_PROGBITS;
1005
1006 if (sec->flags & SEC_SMALL_DATA)
1007 hdr->sh_flags |= SHF_IA_64_SHORT;
1008
1009 return true;
1010}
1011
1012/* Hook called by the linker routine which adds symbols from an object
1013 file. We use it to put .comm items in .sbss, and not .bss. */
1014
1015static boolean
1016elf64_ia64_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1017 bfd *abfd;
1018 struct bfd_link_info *info;
1019 const Elf_Internal_Sym *sym;
1020 const char **namep;
1021 flagword *flagsp;
1022 asection **secp;
1023 bfd_vma *valp;
1024{
1025 if (sym->st_shndx == SHN_COMMON
1026 && !info->relocateable
1027 && sym->st_size <= bfd_get_gp_size (abfd))
1028 {
1029 /* Common symbols less than or equal to -G nn bytes are
1030 automatically put into .sbss. */
1031
1032 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1033
1034 if (scomm == NULL)
1035 {
1036 scomm = bfd_make_section (abfd, ".scommon");
1037 if (scomm == NULL
1038 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1039 | SEC_IS_COMMON
1040 | SEC_LINKER_CREATED)))
1041 return false;
1042 }
1043
1044 *secp = scomm;
1045 *valp = sym->st_size;
1046 }
1047
1048 return true;
1049}
1050
1051/* Return the number of additional phdrs we will need. */
1052
1053static int
1054elf64_ia64_additional_program_headers (abfd)
1055 bfd *abfd;
1056{
1057 asection *s;
1058 int ret = 0;
1059
1060 /* See if we need a PT_IA_64_ARCHEXT segment. */
1061 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1062 if (s && (s->flags & SEC_LOAD))
1063 ++ret;
1064
1065 /* See if we need a PT_IA_64_UNWIND segment. */
1066 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
1067 if (s && (s->flags & SEC_LOAD))
1068 ++ret;
1069
1070 return ret;
1071}
1072
1073static boolean
1074elf64_ia64_modify_segment_map (abfd)
1075 bfd *abfd;
1076{
1077 struct elf_segment_map *m, **pm;
1078 asection *s;
1079
1080 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1081 all PT_LOAD segments. */
1082 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1083 if (s && (s->flags & SEC_LOAD))
1084 {
1085 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1086 if (m->p_type == PT_IA_64_ARCHEXT)
1087 break;
1088 if (m == NULL)
1089 {
1090 m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
1091 if (m == NULL)
1092 return false;
1093
1094 m->p_type = PT_IA_64_ARCHEXT;
1095 m->count = 1;
1096 m->sections[0] = s;
1097
1098 /* We want to put it after the PHDR and INTERP segments. */
1099 pm = &elf_tdata (abfd)->segment_map;
1100 while (*pm != NULL
1101 && ((*pm)->p_type == PT_PHDR
1102 || (*pm)->p_type == PT_INTERP))
1103 pm = &(*pm)->next;
1104
1105 m->next = *pm;
1106 *pm = m;
1107 }
1108 }
1109
1110 /* Install the PT_IA_64_UNWIND segment, if needed. */
1111 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
1112 if (s && (s->flags & SEC_LOAD))
1113 {
1114 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1115 if (m->p_type == PT_IA_64_UNWIND)
1116 break;
1117 if (m == NULL)
1118 {
1119 m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
1120 if (m == NULL)
1121 return false;
1122
1123 m->p_type = PT_IA_64_UNWIND;
1124 m->count = 1;
1125 m->sections[0] = s;
1126 m->next = NULL;
1127
1128 /* We want to put it last. */
1129 pm = &elf_tdata (abfd)->segment_map;
1130 while (*pm != NULL)
1131 pm = &(*pm)->next;
1132 *pm = m;
1133 }
1134 }
1135
1136 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1137 the input sections for each output section in the segment and testing
1138 for SHF_IA_64_NORECOV on each. */
1139 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1140 if (m->p_type == PT_LOAD)
1141 {
1142 int i;
1143 for (i = m->count - 1; i >= 0; --i)
1144 {
1145 struct bfd_link_order *order = m->sections[i]->link_order_head;
1146 while (order)
1147 {
1148 if (order->type == bfd_indirect_link_order)
1149 {
1150 asection *is = order->u.indirect.section;
1151 bfd_vma flags = elf_section_data(is)->this_hdr.sh_flags;
1152 if (flags & SHF_IA_64_NORECOV)
1153 {
1154 m->p_flags |= PF_IA_64_NORECOV;
1155 goto found;
1156 }
1157 }
1158 order = order->next;
1159 }
1160 }
1161 found:;
1162 }
1163
1164 return true;
1165}
1166
1167
1168/* According to the Tahoe assembler spec, all labels starting with a
1169 '.' are local. */
1170
1171static boolean
1172elf64_ia64_is_local_label_name (abfd, name)
1173 bfd *abfd;
1174 const char *name;
1175{
1176 return name[0] == '.';
1177}
1178
1179/* Should we do dynamic things to this symbol? */
1180
1181static boolean
1182elf64_ia64_dynamic_symbol_p (h, info)
1183 struct elf_link_hash_entry *h;
1184 struct bfd_link_info *info;
1185{
1186 if (h == NULL)
1187 return false;
1188
1189 while (h->root.type == bfd_link_hash_indirect
1190 || h->root.type == bfd_link_hash_warning)
1191 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1192
1193 if (h->dynindx == -1)
1194 return false;
1195
1196 if (h->root.type == bfd_link_hash_undefweak
1197 || h->root.type == bfd_link_hash_defweak)
1198 return true;
1199
1200 if ((info->shared && !info->symbolic)
1201 || ((h->elf_link_hash_flags
1202 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
1203 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
1204 return true;
1205
1206 return false;
1207}
1208\f
1209static boolean
1210elf64_ia64_local_hash_table_init (ht, abfd, new)
1211 struct elf64_ia64_local_hash_table *ht;
1212 bfd *abfd;
1213 new_hash_entry_func new;
1214{
1215 memset (ht, 0, sizeof(*ht));
1216 return bfd_hash_table_init (&ht->root, new);
1217}
1218
1219static struct bfd_hash_entry*
1220elf64_ia64_new_loc_hash_entry (entry, table, string)
1221 struct bfd_hash_entry *entry;
1222 struct bfd_hash_table *table;
1223 const char *string;
1224{
1225 struct elf64_ia64_local_hash_entry *ret;
1226 ret = (struct elf64_ia64_local_hash_entry *) entry;
1227
1228 /* Allocate the structure if it has not already been allocated by a
1229 subclass. */
1230 if (!ret)
1231 ret = bfd_hash_allocate (table, sizeof (*ret));
1232
1233 if (!ret)
1234 return 0;
1235
1236 /* Initialize our local data. All zeros, and definitely easier
1237 than setting a handful of bit fields. */
1238 memset (ret, 0, sizeof(*ret));
1239
1240 /* Call the allocation method of the superclass. */
1241 ret = ((struct elf64_ia64_local_hash_entry *)
1242 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
1243
1244 return (struct bfd_hash_entry *) ret;
1245}
1246
1247static struct bfd_hash_entry*
1248elf64_ia64_new_elf_hash_entry (entry, table, string)
1249 struct bfd_hash_entry *entry;
1250 struct bfd_hash_table *table;
1251 const char *string;
1252{
1253 struct elf64_ia64_link_hash_entry *ret;
1254 ret = (struct elf64_ia64_link_hash_entry *) entry;
1255
1256 /* Allocate the structure if it has not already been allocated by a
1257 subclass. */
1258 if (!ret)
1259 ret = bfd_hash_allocate (table, sizeof (*ret));
1260
1261 if (!ret)
1262 return 0;
1263
1264 /* Initialize our local data. All zeros, and definitely easier
1265 than setting a handful of bit fields. */
1266 memset (ret, 0, sizeof(*ret));
1267
1268 /* Call the allocation method of the superclass. */
1269 ret = ((struct elf64_ia64_link_hash_entry *)
1270 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1271 table, string));
1272
1273 return (struct bfd_hash_entry *) ret;
1274}
1275
1276static void
1277elf64_ia64_hash_copy_indirect (xdir, xind)
1278 struct elf_link_hash_entry *xdir, *xind;
1279{
1280 struct elf64_ia64_link_hash_entry *dir, *ind;
1281
1282 dir = (struct elf64_ia64_link_hash_entry *)xdir;
1283 ind = (struct elf64_ia64_link_hash_entry *)xind;
1284
1285 /* Copy down any references that we may have already seen to the
1286 symbol which just became indirect. */
1287
1288 dir->root.elf_link_hash_flags |=
1289 (ind->root.elf_link_hash_flags
1290 & (ELF_LINK_HASH_REF_DYNAMIC
1291 | ELF_LINK_HASH_REF_REGULAR
1292 | ELF_LINK_HASH_REF_REGULAR_NONWEAK));
1293
1294 /* Copy over the got and plt data. This would have been done
1295 by check_relocs. */
1296
1297 if (dir->info == NULL)
1298 {
1299 struct elf64_ia64_dyn_sym_info *dyn_i;
1300
1301 dir->info = dyn_i = ind->info;
1302 ind->info = NULL;
1303
1304 /* Fix up the dyn_sym_info pointers to the global symbol. */
1305 for (; dyn_i; dyn_i = dyn_i->next)
1306 dyn_i->h = &dir->root;
1307 }
1308 BFD_ASSERT (ind->info == NULL);
1309
1310 /* Copy over the dynindx. */
1311
1312 if (dir->root.dynindx == -1)
1313 {
1314 dir->root.dynindx = ind->root.dynindx;
1315 dir->root.dynstr_index = ind->root.dynstr_index;
1316 ind->root.dynindx = -1;
1317 ind->root.dynstr_index = 0;
1318 }
1319 BFD_ASSERT (ind->root.dynindx == -1);
1320}
1321
1322static void
f41cbf03
UC		 1323elf64_ia64_hash_hide_symbol (info, xh)
1324 struct bfd_link_info *info ATTRIBUTE_UNUSED;
800eeca4
JW		 1325 struct elf_link_hash_entry *xh;
1326{
1327 struct elf64_ia64_link_hash_entry *h;
1328 struct elf64_ia64_dyn_sym_info *dyn_i;
1329
1330 h = (struct elf64_ia64_link_hash_entry *)xh;
1331
1332 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1333 h->root.dynindx = -1;
1334
1335 for (dyn_i = h->info; dyn_i; dyn_i = dyn_i->next)
1336 dyn_i->want_plt2 = 0;
1337}
1338
1339/* Create the derived linker hash table. The IA-64 ELF port uses this
1340 derived hash table to keep information specific to the IA-64 ElF
1341 linker (without using static variables). */
1342
1343static struct bfd_link_hash_table*
1344elf64_ia64_hash_table_create (abfd)
1345 bfd *abfd;
1346{
1347 struct elf64_ia64_link_hash_table *ret;
1348
1349 ret = bfd_alloc (abfd, sizeof (*ret));
1350 if (!ret)
1351 return 0;
1352 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1353 elf64_ia64_new_elf_hash_entry))
1354 {
1355 bfd_release (abfd, ret);
1356 return 0;
1357 }
1358
1359 if (!elf64_ia64_local_hash_table_init (&ret->loc_hash_table, abfd,
1360 elf64_ia64_new_loc_hash_entry))
1361 return 0;
1362 return &ret->root.root;
1363}
1364
1365/* Look up an entry in a Alpha ELF linker hash table. */
1366
1367static INLINE struct elf64_ia64_local_hash_entry *
1368elf64_ia64_local_hash_lookup(table, string, create, copy)
1369 struct elf64_ia64_local_hash_table *table;
1370 const char *string;
1371 boolean create, copy;
1372{
1373 return ((struct elf64_ia64_local_hash_entry *)
1374 bfd_hash_lookup (&table->root, string, create, copy));
1375}
1376
1377/* Traverse both local and global hash tables. */
1378
1379struct elf64_ia64_dyn_sym_traverse_data
1380{
1381 boolean (*func) PARAMS ((struct elf64_ia64_dyn_sym_info *, PTR));
1382 PTR data;
1383};
1384
1385static boolean
1386elf64_ia64_global_dyn_sym_thunk (xentry, xdata)
1387 struct bfd_hash_entry *xentry;
1388 PTR xdata;
1389{
1390 struct elf64_ia64_link_hash_entry *entry
1391 = (struct elf64_ia64_link_hash_entry *) xentry;
1392 struct elf64_ia64_dyn_sym_traverse_data *data
1393 = (struct elf64_ia64_dyn_sym_traverse_data *) xdata;
1394 struct elf64_ia64_dyn_sym_info *dyn_i;
1395
1396 for (dyn_i = entry->info; dyn_i; dyn_i = dyn_i->next)
1397 if (! (*data->func) (dyn_i, data->data))
1398 return false;
1399 return true;
1400}
1401
1402static boolean
1403elf64_ia64_local_dyn_sym_thunk (xentry, xdata)
1404 struct bfd_hash_entry *xentry;
1405 PTR xdata;
1406{
1407 struct elf64_ia64_local_hash_entry *entry
1408 = (struct elf64_ia64_local_hash_entry *) xentry;
1409 struct elf64_ia64_dyn_sym_traverse_data *data
1410 = (struct elf64_ia64_dyn_sym_traverse_data *) xdata;
1411 struct elf64_ia64_dyn_sym_info *dyn_i;
1412
1413 for (dyn_i = entry->info; dyn_i; dyn_i = dyn_i->next)
1414 if (! (*data->func) (dyn_i, data->data))
1415 return false;
1416 return true;
1417}
1418
1419static void
1420elf64_ia64_dyn_sym_traverse (ia64_info, func, data)
1421 struct elf64_ia64_link_hash_table *ia64_info;
1422 boolean (*func) PARAMS ((struct elf64_ia64_dyn_sym_info *, PTR));
1423 PTR data;
1424{
1425 struct elf64_ia64_dyn_sym_traverse_data xdata;
1426
1427 xdata.func = func;
1428 xdata.data = data;
1429
1430 elf_link_hash_traverse (&ia64_info->root,
1431 elf64_ia64_global_dyn_sym_thunk, &xdata);
1432 bfd_hash_traverse (&ia64_info->loc_hash_table.root,
1433 elf64_ia64_local_dyn_sym_thunk, &xdata);
1434}
1435\f
1436static boolean
1437elf64_ia64_create_dynamic_sections (abfd, info)
1438 bfd *abfd;
1439 struct bfd_link_info *info;
1440{
1441 struct elf64_ia64_link_hash_table *ia64_info;
1442 struct elf_link_hash_entry *h;
1443 asection *s;
1444
1445 if (! _bfd_elf_create_dynamic_sections (abfd, info))
1446 return false;
1447
1448 ia64_info = elf64_ia64_hash_table (info);
1449
1450 ia64_info->plt_sec = bfd_get_section_by_name (abfd, ".plt");
1451 ia64_info->got_sec = bfd_get_section_by_name (abfd, ".got");
1452
1453 {
1454 flagword flags = bfd_get_section_flags (abfd, ia64_info->got_sec);
1455 bfd_set_section_flags (abfd, ia64_info->got_sec, SEC_SMALL_DATA | flags);
1456 }
1457
1458 if (!get_pltoff (abfd, info, ia64_info))
1459 return false;
1460
1461 s = bfd_make_section(abfd, ".rela.IA_64.pltoff");
1462 if (s == NULL
1463 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1464 | SEC_HAS_CONTENTS
1465 | SEC_IN_MEMORY
1466 | SEC_LINKER_CREATED
1467 | SEC_READONLY))
1468 || !bfd_set_section_alignment (abfd, s, 3))
1469 return false;
1470 ia64_info->rel_pltoff_sec = s;
1471
1472 s = bfd_make_section(abfd, ".rela.got");
1473 if (s == NULL
1474 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1475 | SEC_HAS_CONTENTS
1476 | SEC_IN_MEMORY
1477 | SEC_LINKER_CREATED
1478 | SEC_READONLY))
1479 || !bfd_set_section_alignment (abfd, s, 3))
1480 return false;
1481 ia64_info->rel_got_sec = s;
1482
1483 return true;
1484}
1485
1486/* Find and/or create a descriptor for dynamic symbol info. This will
1487 vary based on global or local symbol, and the addend to the reloc. */
1488
1489static struct elf64_ia64_dyn_sym_info *
1490get_dyn_sym_info (ia64_info, h, abfd, rel, create)
1491 struct elf64_ia64_link_hash_table *ia64_info;
1492 struct elf_link_hash_entry *h;
1493 bfd *abfd;
1494 const Elf_Internal_Rela *rel;
1495 boolean create;
1496{
1497 struct elf64_ia64_dyn_sym_info **pp;
1498 struct elf64_ia64_dyn_sym_info *dyn_i;
1499 bfd_vma addend = rel ? rel->r_addend : 0;
1500
1501 if (h)
1502 pp = &((struct elf64_ia64_link_hash_entry *)h)->info;
1503 else
1504 {
1505 struct elf64_ia64_local_hash_entry *loc_h;
1506 char *addr_name;
1507 size_t len;
1508
1509 /* Construct a string for use in the elf64_ia64_local_hash_table.
1510 The name describes what was once anonymous memory. */
1511
1512 len = sizeof(void*)*2 + 1 + sizeof(bfd_vma)*4 + 1 + 1;
1513 len += 10; /* %p slop */
1514
1515 addr_name = alloca (len);
1516 sprintf (addr_name, "%p:%lx", abfd, ELF64_R_SYM (rel->r_info));
1517
1518 /* Collect the canonical entry data for this address. */
1519 loc_h = elf64_ia64_local_hash_lookup (&ia64_info->loc_hash_table,
1520 addr_name, create, create);
1521 BFD_ASSERT (loc_h);
1522
1523 pp = &loc_h->info;
1524 }
1525
1526 for (dyn_i = *pp; dyn_i && dyn_i->addend != addend; dyn_i = *pp)
1527 pp = &dyn_i->next;
1528
1529 if (dyn_i == NULL && create)
1530 {
1531 dyn_i = (struct elf64_ia64_dyn_sym_info *)
1532 bfd_zalloc (abfd, sizeof *dyn_i);
1533 *pp = dyn_i;
1534 dyn_i->addend = addend;
1535 }
1536
1537 return dyn_i;
1538}
1539
1540static asection *
1541get_got (abfd, info, ia64_info)
1542 bfd *abfd;
1543 struct bfd_link_info *info;
1544 struct elf64_ia64_link_hash_table *ia64_info;
1545{
1546 asection *got, *srel;
1547 bfd *dynobj;
1548
1549 got = ia64_info->got_sec;
1550 if (!got)
1551 {
1552 flagword flags;
1553
1554 dynobj = ia64_info->root.dynobj;
1555 if (!dynobj)
1556 ia64_info->root.dynobj = dynobj = abfd;
1557 if (!_bfd_elf_create_got_section (dynobj, info))
1558 return 0;
1559
1560 got = bfd_get_section_by_name (dynobj, ".got");
1561 BFD_ASSERT (got);
1562 ia64_info->got_sec = got;
1563
1564 flags = bfd_get_section_flags (abfd, got);
1565 bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags);
1566 }
1567
1568 return got;
1569}
1570
1571/* Create function descriptor section (.opd). This section is called .opd
1572 because it contains "official prodecure descriptors". The "official"
1573 refers to the fact that these descriptors are used when taking the address
1574 of a procedure, thus ensuring a unique address for each procedure. */
1575
1576static asection *
1577get_fptr (abfd, info, ia64_info)
1578 bfd *abfd;
1579 struct bfd_link_info *info;
1580 struct elf64_ia64_link_hash_table *ia64_info;
1581{
1582 asection *fptr;
1583 bfd *dynobj;
1584
1585 fptr = ia64_info->fptr_sec;
1586 if (!fptr)
1587 {
1588 dynobj = ia64_info->root.dynobj;
1589 if (!dynobj)
1590 ia64_info->root.dynobj = dynobj = abfd;
1591
1592 fptr = bfd_make_section (dynobj, ".opd");
1593 if (!fptr
1594 || !bfd_set_section_flags (dynobj, fptr,
1595 (SEC_ALLOC
1596 | SEC_LOAD
1597 | SEC_HAS_CONTENTS
1598 | SEC_IN_MEMORY
1599 | SEC_READONLY
1600 | SEC_LINKER_CREATED))
1601 || !bfd_set_section_alignment (abfd, fptr, 4))
1602 {
1603 BFD_ASSERT (0);
1604 return NULL;
1605 }
1606
1607 ia64_info->fptr_sec = fptr;
1608 }
1609
1610 return fptr;
1611}
1612
1613static asection *
1614get_pltoff (abfd, info, ia64_info)
1615 bfd *abfd;
1616 struct bfd_link_info *info;
1617 struct elf64_ia64_link_hash_table *ia64_info;
1618{
1619 asection *pltoff;
1620 bfd *dynobj;
1621
1622 pltoff = ia64_info->pltoff_sec;
1623 if (!pltoff)
1624 {
1625 dynobj = ia64_info->root.dynobj;
1626 if (!dynobj)
1627 ia64_info->root.dynobj = dynobj = abfd;
1628
1629 pltoff = bfd_make_section (dynobj, ELF_STRING_ia64_pltoff);
1630 if (!pltoff
1631 || !bfd_set_section_flags (dynobj, pltoff,
1632 (SEC_ALLOC
1633 | SEC_LOAD
1634 | SEC_HAS_CONTENTS
1635 | SEC_IN_MEMORY
1636 | SEC_SMALL_DATA
1637 | SEC_LINKER_CREATED))
1638 || !bfd_set_section_alignment (abfd, pltoff, 4))
1639 {
1640 BFD_ASSERT (0);
1641 return NULL;
1642 }
1643
1644 ia64_info->pltoff_sec = pltoff;
1645 }
1646
1647 return pltoff;
1648}
1649
1650static asection *
1651get_reloc_section (abfd, ia64_info, sec, create)
1652 bfd *abfd;
1653 struct elf64_ia64_link_hash_table *ia64_info;
1654 asection *sec;
1655 boolean create;
1656{
1657 const char *srel_name;
1658 asection *srel;
1659 bfd *dynobj;
1660
1661 srel_name = (bfd_elf_string_from_elf_section
1662 (abfd, elf_elfheader(abfd)->e_shstrndx,
1663 elf_section_data(sec)->rel_hdr.sh_name));
1664 if (srel_name == NULL)
1665 return NULL;
1666
1667 BFD_ASSERT ((strncmp (srel_name, ".rela", 5) == 0
1668 && strcmp (bfd_get_section_name (abfd, sec),
1669 srel_name+5) == 0)
1670 || (strncmp (srel_name, ".rel", 4) == 0
1671 && strcmp (bfd_get_section_name (abfd, sec),
1672 srel_name+4) == 0));
1673
1674 dynobj = ia64_info->root.dynobj;
1675 if (!dynobj)
1676 ia64_info->root.dynobj = dynobj = abfd;
1677
1678 srel = bfd_get_section_by_name (dynobj, srel_name);
1679 if (srel == NULL && create)
1680 {
1681 srel = bfd_make_section (dynobj, srel_name);
1682 if (srel == NULL
1683 || !bfd_set_section_flags (dynobj, srel,
1684 (SEC_ALLOC
1685 | SEC_LOAD
1686 | SEC_HAS_CONTENTS
1687 | SEC_IN_MEMORY
1688 | SEC_LINKER_CREATED
1689 | SEC_READONLY))
1690 || !bfd_set_section_alignment (dynobj, srel, 3))
1691 return NULL;
1692 }
1693
1694 return srel;
1695}
1696
1697static boolean
1698count_dyn_reloc (abfd, dyn_i, srel, type)
1699 bfd *abfd;
1700 struct elf64_ia64_dyn_sym_info *dyn_i;
1701 asection *srel;
1702 int type;
1703{
1704 struct elf64_ia64_dyn_reloc_entry *rent;
1705
1706 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
1707 if (rent->srel == srel && rent->type == type)
1708 break;
1709
1710 if (!rent)
1711 {
1712 rent = (struct elf64_ia64_dyn_reloc_entry *)
1713 bfd_alloc (abfd, sizeof (*rent));
1714 if (!rent)
1715 return false;
1716
1717 rent->next = dyn_i->reloc_entries;
1718 rent->srel = srel;
1719 rent->type = type;
1720 rent->count = 0;
1721 dyn_i->reloc_entries = rent;
1722 }
1723 rent->count++;
1724
1725 return true;
1726}
1727
1728static boolean
1729elf64_ia64_check_relocs (abfd, info, sec, relocs)
1730 bfd *abfd;
1731 struct bfd_link_info *info;
1732 asection *sec;
1733 const Elf_Internal_Rela *relocs;
1734{
1735 struct elf64_ia64_link_hash_table *ia64_info;
1736 const Elf_Internal_Rela *relend;
1737 Elf_Internal_Shdr *symtab_hdr;
1738 const Elf_Internal_Rela *rel;
1739 asection *got, *fptr, *srel;
1740
1741 if (info->relocateable)
1742 return true;
1743
1744 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1745 ia64_info = elf64_ia64_hash_table (info);
1746
1747 got = fptr = srel = NULL;
1748
1749 relend = relocs + sec->reloc_count;
1750 for (rel = relocs; rel < relend; ++rel)
1751 {
1752 enum {
1753 NEED_GOT = 1,
1754 NEED_FPTR = 2,
1755 NEED_PLTOFF = 4,
1756 NEED_MIN_PLT = 8,
1757 NEED_FULL_PLT = 16,
1758 NEED_DYNREL = 32,
1759 NEED_LTOFF_FPTR = 64,
1760 };
1761
1762 struct elf_link_hash_entry *h = NULL;
1763 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
1764 struct elf64_ia64_dyn_sym_info *dyn_i;
1765 int need_entry;
1766 boolean maybe_dynamic;
1767 int dynrel_type;
1768
1769 if (r_symndx >= symtab_hdr->sh_info)
1770 {
1771 /* We're dealing with a global symbol -- find its hash entry
1772 and mark it as being referenced. */
1773 long indx = r_symndx - symtab_hdr->sh_info;
1774 h = elf_sym_hashes (abfd)[indx];
1775 while (h->root.type == bfd_link_hash_indirect
1776 || h->root.type == bfd_link_hash_warning)
1777 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1778
1779 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
1780 }
1781
1782 /* We can only get preliminary data on whether a symbol is
1783 locally or externally defined, as not all of the input files
1784 have yet been processed. Do something with what we know, as
1785 this may help reduce memory usage and processing time later. */
1786 maybe_dynamic = false;
1787 if (h && ((info->shared && ! info->symbolic)
1788 || ! (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
1789 || h->root.type == bfd_link_hash_defweak))
1790 maybe_dynamic = true;
1791
1792 need_entry = 0;
1793 switch (ELF64_R_TYPE (rel->r_info))
1794 {
1795 case R_IA64_TPREL22:
1796 case R_IA64_TPREL64MSB:
1797 case R_IA64_TPREL64LSB:
1798 case R_IA64_LTOFF_TP22:
1799 return false;
1800
1801 case R_IA64_LTOFF_FPTR22:
1802 case R_IA64_LTOFF_FPTR64I:
1803 case R_IA64_LTOFF_FPTR64MSB:
1804 case R_IA64_LTOFF_FPTR64LSB:
1805 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
1806 break;
1807
1808 case R_IA64_FPTR64I:
1809 case R_IA64_FPTR32MSB:
1810 case R_IA64_FPTR32LSB:
1811 case R_IA64_FPTR64MSB:
1812 case R_IA64_FPTR64LSB:
1813 if (info->shared || h)
1814 need_entry = NEED_FPTR | NEED_DYNREL;
1815 else
1816 need_entry = NEED_FPTR;
1817 dynrel_type = R_IA64_FPTR64LSB;
1818 break;
1819
1820 case R_IA64_LTOFF22:
1821 case R_IA64_LTOFF22X:
1822 case R_IA64_LTOFF64I:
1823 need_entry = NEED_GOT;
1824 break;
1825
1826 case R_IA64_PLTOFF22:
1827 case R_IA64_PLTOFF64I:
1828 case R_IA64_PLTOFF64MSB:
1829 case R_IA64_PLTOFF64LSB:
1830 need_entry = NEED_PLTOFF;
1831 if (h)
1832 {
1833 if (maybe_dynamic)
1834 need_entry |= NEED_MIN_PLT;
1835 }
1836 else
1837 {
1838 (*info->callbacks->warning)
1839 (info, _("@pltoff reloc against local symbol"), 0,
1840 abfd, 0, 0);
1841 }
1842 break;
1843
1844 case R_IA64_PCREL21B:
748abff6 1845 case R_IA64_PCREL60B:
800eeca4
JW		 1846 /* Depending on where this symbol is defined, we may or may not
1847 need a full plt entry. Only skip if we know we'll not need
1848 the entry -- static or symbolic, and the symbol definition
1849 has already been seen. */
1850 if (maybe_dynamic && rel->r_addend == 0)
1851 need_entry = NEED_FULL_PLT;
1852 break;
1853
1854 case R_IA64_IMM14:
1855 case R_IA64_IMM22:
1856 case R_IA64_IMM64:
1857 case R_IA64_DIR32MSB:
1858 case R_IA64_DIR32LSB:
1859 case R_IA64_DIR64MSB:
1860 case R_IA64_DIR64LSB:
1861 /* Shared objects will always need at least a REL relocation. */
1862 if (info->shared || maybe_dynamic)
1863 need_entry = NEED_DYNREL;
1864 dynrel_type = R_IA64_DIR64LSB;
1865 break;
1866
748abff6
RH		 1867 case R_IA64_PCREL22:
1868 case R_IA64_PCREL64I:
800eeca4
JW		 1869 case R_IA64_PCREL32MSB:
1870 case R_IA64_PCREL32LSB:
1871 case R_IA64_PCREL64MSB:
1872 case R_IA64_PCREL64LSB:
1873 if (maybe_dynamic)
1874 need_entry = NEED_DYNREL;
1875 dynrel_type = R_IA64_PCREL64LSB;
1876 break;
1877 }
1878
1879 if (!need_entry)
1880 continue;
1881
1882 if ((need_entry & NEED_FPTR) != 0
1883 && rel->r_addend)
1884 {
1885 (*info->callbacks->warning)
1886 (info, _("non-zero addend in @fptr reloc"), 0,
1887 abfd, 0, 0);
1888 }
1889
1890 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, true);
1891
1892 /* Record whether or not this is a local symbol. */
1893 dyn_i->h = h;
1894
1895 /* Create what's needed. */
1896 if (need_entry & NEED_GOT)
1897 {
1898 if (!got)
1899 {
1900 got = get_got (abfd, info, ia64_info);
1901 if (!got)
1902 return false;
1903 }
1904 dyn_i->want_got = 1;
1905 }
1906 if (need_entry & NEED_FPTR)
1907 {
1908 if (!fptr)
1909 {
1910 fptr = get_fptr (abfd, info, ia64_info);
1911 if (!fptr)
1912 return false;
1913 }
1914
1915 /* FPTRs for shared libraries are allocated by the dynamic
1916 linker. Make sure this local symbol will appear in the
1917 dynamic symbol table. */
1918 if (!h && info->shared)
1919 {
1920 if (! (_bfd_elf64_link_record_local_dynamic_symbol
1921 (info, abfd, r_symndx)))
1922 return false;
1923 }
1924
1925 dyn_i->want_fptr = 1;
1926 }
1927 if (need_entry & NEED_LTOFF_FPTR)
1928 dyn_i->want_ltoff_fptr = 1;
1929 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
1930 {
1931 if (!ia64_info->root.dynobj)
1932 ia64_info->root.dynobj = abfd;
1933 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1934 dyn_i->want_plt = 1;
1935 }
1936 if (need_entry & NEED_FULL_PLT)
1937 dyn_i->want_plt2 = 1;
1938 if (need_entry & NEED_PLTOFF)
1939 dyn_i->want_pltoff = 1;
1940 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
1941 {
1942 if (!srel)
1943 {
1944 srel = get_reloc_section (abfd, ia64_info, sec, true);
1945 if (!srel)
1946 return false;
1947 }
1948 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type))
1949 return false;
1950 }
1951 }
1952
1953 return true;
1954}
1955
1956struct elf64_ia64_allocate_data
1957{
1958 struct bfd_link_info *info;
1959 bfd_size_type ofs;
1960};
1961
1962/* For cleanliness, and potentially faster dynamic loading, allocate
1963 external GOT entries first. */
1964
1965static boolean
1966allocate_global_data_got (dyn_i, data)
1967 struct elf64_ia64_dyn_sym_info *dyn_i;
1968 PTR data;
1969{
1970 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
1971
1972 if (dyn_i->want_got
1973 && ! dyn_i->want_fptr
1974 && elf64_ia64_dynamic_symbol_p (dyn_i->h, x->info))
1975 {
1976 dyn_i->got_offset = x->ofs;
1977 x->ofs += 8;
1978 }
1979 return true;
1980}
1981
1982/* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
1983
1984static boolean
1985allocate_global_fptr_got (dyn_i, data)
1986 struct elf64_ia64_dyn_sym_info *dyn_i;
1987 PTR data;
1988{
1989 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
1990
1991 if (dyn_i->want_got
1992 && dyn_i->want_fptr
1993 && elf64_ia64_dynamic_symbol_p (dyn_i->h, x->info))
1994 {
1995 dyn_i->got_offset = x->ofs;
1996 x->ofs += 8;
1997 }
1998 return true;
1999}
2000
2001/* Lastly, allocate all the GOT entries for local data. */
2002
2003static boolean
2004allocate_local_got (dyn_i, data)
2005 struct elf64_ia64_dyn_sym_info *dyn_i;
2006 PTR data;
2007{
2008 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2009
2010 if (dyn_i->want_got
2011 && ! elf64_ia64_dynamic_symbol_p (dyn_i->h, x->info))
2012 {
2013 dyn_i->got_offset = x->ofs;
2014 x->ofs += 8;
2015 }
2016 return true;
2017}
2018
2019/* Search for the index of a global symbol in it's defining object file. */
2020
2021static unsigned long
2022global_sym_index (h)
2023 struct elf_link_hash_entry *h;
2024{
2025 struct elf_link_hash_entry **p;
2026 bfd *obj;
2027
2028 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2029 || h->root.type == bfd_link_hash_defweak);
2030
2031 obj = h->root.u.def.section->owner;
2032 for (p = elf_sym_hashes (obj); *p != h; ++p)
2033 continue;
2034
2035 return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
2036}
2037
2038/* Allocate function descriptors. We can do these for every function
2039 in a main executable that is not exported. */
2040
2041static boolean
2042allocate_fptr (dyn_i, data)
2043 struct elf64_ia64_dyn_sym_info *dyn_i;
2044 PTR data;
2045{
2046 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2047
2048 if (dyn_i->want_fptr)
2049 {
2050 struct elf_link_hash_entry *h = dyn_i->h;
2051
2052 if (h)
2053 while (h->root.type == bfd_link_hash_indirect
2054 || h->root.type == bfd_link_hash_warning)
2055 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2056
2057 if (x->info->shared)
2058 {
2059 if (h && h->dynindx == -1)
2060 {
2061 BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
2062 || (h->root.type == bfd_link_hash_defweak));
2063
2064 if (!_bfd_elf64_link_record_local_dynamic_symbol
2065 (x->info, h->root.u.def.section->owner,
2066 global_sym_index (h)))
2067 return false;
2068 }
2069
2070 dyn_i->want_fptr = 0;
2071 }
2072 else if (h == NULL || h->dynindx == -1)
2073 {
2074 dyn_i->fptr_offset = x->ofs;
2075 x->ofs += 16;
2076 }
2077 else
2078 dyn_i->want_fptr = 0;
2079 }
2080 return true;
2081}
2082
2083/* Allocate all the minimal PLT entries. */
2084
2085static boolean
2086allocate_plt_entries (dyn_i, data)
2087 struct elf64_ia64_dyn_sym_info *dyn_i;
2088 PTR data;
2089{
2090 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2091
2092 if (dyn_i->want_plt)
2093 {
2094 struct elf_link_hash_entry *h = dyn_i->h;
2095
2096 if (h)
2097 while (h->root.type == bfd_link_hash_indirect
2098 || h->root.type == bfd_link_hash_warning)
2099 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2100
2101 /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT. */
2102 if (elf64_ia64_dynamic_symbol_p (h, x->info))
2103 {
2104 bfd_size_type offset = x->ofs;
2105 if (offset == 0)
2106 offset = PLT_HEADER_SIZE;
2107 dyn_i->plt_offset = offset;
2108 x->ofs = offset + PLT_MIN_ENTRY_SIZE;
2109
2110 dyn_i->want_pltoff = 1;
2111 }
2112 else
2113 {
2114 dyn_i->want_plt = 0;
2115 dyn_i->want_plt2 = 0;
2116 }
2117 }
2118 return true;
2119}
2120
2121/* Allocate all the full PLT entries. */
2122
2123static boolean
2124allocate_plt2_entries (dyn_i, data)
2125 struct elf64_ia64_dyn_sym_info *dyn_i;
2126 PTR data;
2127{
2128 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2129
2130 if (dyn_i->want_plt2)
2131 {
2132 struct elf_link_hash_entry *h = dyn_i->h;
2133 bfd_size_type ofs = x->ofs;
2134
2135 dyn_i->plt2_offset = ofs;
2136 x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2137
2138 while (h->root.type == bfd_link_hash_indirect
2139 || h->root.type == bfd_link_hash_warning)
2140 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2141 dyn_i->h->plt.offset = ofs;
2142 }
2143 return true;
2144}
2145
2146/* Allocate all the PLTOFF entries requested by relocations and
2147 plt entries. We can't share space with allocated FPTR entries,
2148 because the latter are not necessarily addressable by the GP.
2149 ??? Relaxation might be able to determine that they are. */
2150
2151static boolean
2152allocate_pltoff_entries (dyn_i, data)
2153 struct elf64_ia64_dyn_sym_info *dyn_i;
2154 PTR data;
2155{
2156 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2157
2158 if (dyn_i->want_pltoff)
2159 {
2160 dyn_i->pltoff_offset = x->ofs;
2161 x->ofs += 16;
2162 }
2163 return true;
2164}
2165
2166/* Allocate dynamic relocations for those symbols that turned out
2167 to be dynamic. */
2168
2169static boolean
2170allocate_dynrel_entries (dyn_i, data)
2171 struct elf64_ia64_dyn_sym_info *dyn_i;
2172 PTR data;
2173{
2174 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2175 struct elf64_ia64_link_hash_table *ia64_info;
2176 struct elf64_ia64_dyn_reloc_entry *rent;
2177 boolean dynamic_symbol, shared;
2178
2179 ia64_info = elf64_ia64_hash_table (x->info);
2180 dynamic_symbol = elf64_ia64_dynamic_symbol_p (dyn_i->h, x->info);
2181 shared = x->info->shared;
2182
2183 /* Take care of the normal data relocations. */
2184
2185 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2186 {
2187 switch (rent->type)
2188 {
2189 case R_IA64_FPTR64LSB:
2190 /* Allocate one iff !want_fptr, which by this point will
2191 be true only if we're actually allocating one statically
2192 in the main executable. */
2193 if (dyn_i->want_fptr)
2194 continue;
2195 break;
2196 case R_IA64_PCREL64LSB:
2197 if (!dynamic_symbol)
2198 continue;
2199 break;
2200 case R_IA64_DIR64LSB:
2201 if (!dynamic_symbol && !shared)
2202 continue;
2203 break;
2204 }
2205 rent->srel->_raw_size += sizeof (Elf64_External_Rela) * rent->count;
2206 }
2207
2208 /* Take care of the GOT and PLT relocations. */
2209
2210 if (((dynamic_symbol || shared) && dyn_i->want_got)
2211 || (dyn_i->want_ltoff_fptr && dyn_i->h && dyn_i->h->dynindx != -1))
2212 ia64_info->rel_got_sec->_raw_size += sizeof (Elf64_External_Rela);
2213
2214 if (dyn_i->want_pltoff)
2215 {
2216 bfd_size_type t = 0;
2217
2218 /* Dynamic symbols get one IPLT relocation. Local symbols in
2219 shared libraries get two REL relocations. Local symbols in
2220 main applications get nothing. */
2221 if (dynamic_symbol)
2222 t = sizeof (Elf64_External_Rela);
2223 else if (shared)
2224 t = 2 * sizeof (Elf64_External_Rela);
2225
2226 ia64_info->rel_pltoff_sec->_raw_size += t;
2227 }
2228
2229 return true;
2230}
2231
2232static boolean
2233elf64_ia64_adjust_dynamic_symbol (info, h)
2234 struct bfd_link_info *info;
2235 struct elf_link_hash_entry *h;
2236{
2237 /* ??? Undefined symbols with PLT entries should be re-defined
2238 to be the PLT entry. */
2239
2240 /* If this is a weak symbol, and there is a real definition, the
2241 processor independent code will have arranged for us to see the
2242 real definition first, and we can just use the same value. */
2243 if (h->weakdef != NULL)
2244 {
2245 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2246 || h->weakdef->root.type == bfd_link_hash_defweak);
2247 h->root.u.def.section = h->weakdef->root.u.def.section;
2248 h->root.u.def.value = h->weakdef->root.u.def.value;
2249 return true;
2250 }
2251
2252 /* If this is a reference to a symbol defined by a dynamic object which
2253 is not a function, we might allocate the symbol in our .dynbss section
2254 and allocate a COPY dynamic relocation.
2255
2256 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2257 of hackery. */
2258
2259 return true;
2260}
2261
2262static boolean
2263elf64_ia64_size_dynamic_sections (output_bfd, info)
2264 bfd *output_bfd;
2265 struct bfd_link_info *info;
2266{
2267 struct elf64_ia64_allocate_data data;
2268 struct elf64_ia64_link_hash_table *ia64_info;
2269 asection *sec;
2270 bfd *dynobj;
2271 boolean reltext = false;
2272 boolean relplt = false;
2273
2274 dynobj = elf_hash_table(info)->dynobj;
2275 ia64_info = elf64_ia64_hash_table (info);
2276 BFD_ASSERT(dynobj != NULL);
2277 data.info = info;
2278
2279 /* Set the contents of the .interp section to the interpreter. */
2280 if (ia64_info->root.dynamic_sections_created
2281 && !info->shared)
2282 {
2283 sec = bfd_get_section_by_name (dynobj, ".interp");
2284 BFD_ASSERT (sec != NULL);
2285 sec->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
2286 sec->_raw_size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
2287 }
2288
2289 /* DT_INIT and DT_FINI get function descriptors not raw code addresses.
2290 Force their symbols to have pltoff entries so we can use those. */
2291 if (ia64_info->root.dynamic_sections_created)
2292 {
2293 struct elf_link_hash_entry *h;
2294 struct elf64_ia64_dyn_sym_info *dyn_i;
2295
2296 if (info->init_function
2297 && (h = elf_link_hash_lookup (elf_hash_table (info),
2298 info->init_function, false,
2299 false, false))
2300 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
2301 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
2302 {
2303 dyn_i = get_dyn_sym_info (ia64_info, h, output_bfd, NULL, true);
2304 dyn_i->want_pltoff = 1;
2305 }
2306
2307 if (info->fini_function
2308 && (h = elf_link_hash_lookup (elf_hash_table (info),
2309 info->fini_function, false,
2310 false, false))
2311 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
2312 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
2313 {
2314 dyn_i = get_dyn_sym_info (ia64_info, h, output_bfd, NULL, true);
2315 dyn_i->want_pltoff = 1;
2316 }
2317 }
2318
2319 /* Allocate the GOT entries. */
2320
2321 if (ia64_info->got_sec)
2322 {
2323 data.ofs = 0;
2324 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
2325 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
2326 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
2327 ia64_info->got_sec->_raw_size = data.ofs;
2328 }
2329
2330 /* Allocate the FPTR entries. */
2331
2332 if (ia64_info->fptr_sec)
2333 {
2334 data.ofs = 0;
2335 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
2336 ia64_info->fptr_sec->_raw_size = data.ofs;
2337 }
2338
2339 /* Now that we've seen all of the input files, we can decide which
2340 symbols need plt entries. Allocate the minimal PLT entries first.
2341 We do this even though dynamic_sections_created may be false, because
2342 this has the side-effect of clearing want_plt and want_plt2. */
2343
2344 data.ofs = 0;
2345 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
2346
2347 ia64_info->minplt_entries = 0;
2348 if (data.ofs)
2349 {
2350 ia64_info->minplt_entries
2351 = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
2352 }
2353
2354 /* Align the pointer for the plt2 entries. */
2355 data.ofs = (data.ofs + 31) & -32;
2356
2357 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
2358 if (data.ofs != 0)
2359 {
2360 BFD_ASSERT (ia64_info->root.dynamic_sections_created);
2361
2362 ia64_info->plt_sec->_raw_size = data.ofs;
2363
2364 /* If we've got a .plt, we need some extra memory for the dynamic
2365 linker. We stuff these in .got.plt. */
2366 sec = bfd_get_section_by_name (dynobj, ".got.plt");
2367 sec->_raw_size = 8 * PLT_RESERVED_WORDS;
2368 }
2369
2370 /* Allocate the PLTOFF entries. */
2371
2372 if (ia64_info->pltoff_sec)
2373 {
2374 data.ofs = 0;
2375 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
2376 ia64_info->pltoff_sec->_raw_size = data.ofs;
2377 }
2378
2379 if (ia64_info->root.dynamic_sections_created)
2380 {
2381 /* Allocate space for the dynamic relocations that turned out to be
2382 required. */
2383
2384 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
2385 }
2386
2387 /* We have now determined the sizes of the various dynamic sections.
2388 Allocate memory for them. */
2389 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2390 {
2391 boolean strip;
2392
2393 if (!(sec->flags & SEC_LINKER_CREATED))
2394 continue;
2395
2396 /* If we don't need this section, strip it from the output file.
2397 There were several sections primarily related to dynamic
2398 linking that must be create before the linker maps input
2399 sections to output sections. The linker does that before
2400 bfd_elf_size_dynamic_sections is called, and it is that
2401 function which decides whether anything needs to go into
2402 these sections. */
2403
2404 strip = (sec->_raw_size == 0);
2405
2406 if (sec == ia64_info->got_sec)
2407 strip = false;
2408 else if (sec == ia64_info->rel_got_sec)
2409 {
2410 if (strip)
2411 ia64_info->rel_got_sec = NULL;
2412 else
2413 /* We use the reloc_count field as a counter if we need to
2414 copy relocs into the output file. */
2415 sec->reloc_count = 0;
2416 }
2417 else if (sec == ia64_info->fptr_sec)
2418 {
2419 if (strip)
2420 ia64_info->fptr_sec = NULL;
2421 }
2422 else if (sec == ia64_info->plt_sec)
2423 {
2424 if (strip)
2425 ia64_info->plt_sec = NULL;
2426 }
2427 else if (sec == ia64_info->pltoff_sec)
2428 {
2429 if (strip)
2430 ia64_info->pltoff_sec = NULL;
2431 }
2432 else if (sec == ia64_info->rel_pltoff_sec)
2433 {
2434 if (strip)
2435 ia64_info->rel_pltoff_sec = NULL;
2436 else
2437 {
2438 relplt = true;
2439 /* We use the reloc_count field as a counter if we need to
2440 copy relocs into the output file. */
2441 sec->reloc_count = 0;
2442 }
2443 }
2444 else
2445 {
2446 const char *name;
2447
2448 /* It's OK to base decisions on the section name, because none
2449 of the dynobj section names depend upon the input files. */
2450 name = bfd_get_section_name (dynobj, sec);
2451
2452 if (strcmp (name, ".got.plt") == 0)
2453 strip = false;
2454 else if (strncmp (name, ".rel", 4) == 0)
2455 {
2456 if (!strip)
2457 {
2458 const char *outname;
2459 asection *target;
2460
2461 /* If this relocation section applies to a read only
2462 section, then we probably need a DT_TEXTREL entry. */
2463 outname = bfd_get_section_name (output_bfd,
2464 sec->output_section);
2465 if (outname[4] == 'a')
2466 outname += 5;
2467 else
2468 outname += 4;
2469
2470 target = bfd_get_section_by_name (output_bfd, outname);
2471 if (target != NULL
2472 && (target->flags & SEC_READONLY) != 0
2473 && (target->flags & SEC_ALLOC) != 0)
2474 reltext = true;
2475
2476 /* We use the reloc_count field as a counter if we need to
2477 copy relocs into the output file. */
2478 sec->reloc_count = 0;
2479 }
2480 }
2481 else
2482 continue;
2483 }
2484
2485 if (strip)
2486 _bfd_strip_section_from_output (info, sec);
2487 else
2488 {
2489 /* Allocate memory for the section contents. */
2490 sec->contents = (bfd_byte *) bfd_zalloc(dynobj, sec->_raw_size);
2491 if (sec->contents == NULL && sec->_raw_size != 0)
2492 return false;
2493 }
2494 }
2495
2496 if (elf_hash_table (info)->dynamic_sections_created)
2497 {
2498 /* Add some entries to the .dynamic section. We fill in the values
2499 later (in finish_dynamic_sections) but we must add the entries now
2500 so that we get the correct size for the .dynamic section. */
2501
2502 if (!info->shared)
2503 {
2504 /* The DT_DEBUG entry is filled in by the dynamic linker and used
2505 by the debugger. */
2506 if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
2507 return false;
2508 }
2509
2510 if (! bfd_elf64_add_dynamic_entry (info, DT_IA_64_PLT_RESERVE, 0))
2511 return false;
2512 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
2513 return false;
2514
2515 if (relplt)
2516 {
2517 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2518 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
2519 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
2520 return false;
2521 }
2522
2523 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
2524 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
2525 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
2526 sizeof(Elf64_External_Rela)))
2527 return false;
2528
2529 if (reltext)
2530 {
2531 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
2532 return false;
d6cf2879 2533 info->flags |= DF_TEXTREL;
800eeca4
JW		 2534 }
2535 }
2536
2537 /* ??? Perhaps force __gp local. */
2538
2539 return true;
2540}
2541
2542static bfd_reloc_status_type
2543elf64_ia64_install_value (abfd, hit_addr, val, r_type)
2544 bfd *abfd;
2545 bfd_byte *hit_addr;
2546 bfd_vma val;
2547 unsigned int r_type;
2548{
2549 const struct ia64_operand *op;
2550 int bigendian = 0, shift = 0;
2551 bfd_vma t0, t1, insn, dword;
2552 enum ia64_opnd opnd;
2553 const char *err;
2554 size_t size = 8;
2555
2556 opnd = IA64_OPND_NIL;
2557 switch (r_type)
2558 {
2559 case R_IA64_NONE:
2560 case R_IA64_LDXMOV:
2561 return bfd_reloc_ok;
2562
2563 /* Instruction relocations. */
2564
2565 case R_IA64_IMM14: opnd = IA64_OPND_IMM14; break;
748abff6 2566
800eeca4
JW		 2567 case R_IA64_PCREL21F: opnd = IA64_OPND_TGT25; break;
2568 case R_IA64_PCREL21M: opnd = IA64_OPND_TGT25b; break;
748abff6
RH		 2569 case R_IA64_PCREL60B: opnd = IA64_OPND_TGT64; break;
2570 case R_IA64_PCREL21B:
2571 case R_IA64_PCREL21BI:
2572 opnd = IA64_OPND_TGT25c;
2573 break;
800eeca4
JW		 2574
2575 case R_IA64_IMM22:
2576 case R_IA64_GPREL22:
2577 case R_IA64_LTOFF22:
2578 case R_IA64_LTOFF22X:
2579 case R_IA64_PLTOFF22:
748abff6 2580 case R_IA64_PCREL22:
800eeca4
JW		 2581 case R_IA64_LTOFF_FPTR22:
2582 opnd = IA64_OPND_IMM22;
2583 break;
2584
2585 case R_IA64_IMM64:
2586 case R_IA64_GPREL64I:
2587 case R_IA64_LTOFF64I:
2588 case R_IA64_PLTOFF64I:
748abff6 2589 case R_IA64_PCREL64I:
800eeca4
JW		 2590 case R_IA64_FPTR64I:
2591 case R_IA64_LTOFF_FPTR64I:
2592 opnd = IA64_OPND_IMMU64;
2593 break;
2594
2595 /* Data relocations. */
2596
2597 case R_IA64_DIR32MSB:
2598 case R_IA64_GPREL32MSB:
2599 case R_IA64_FPTR32MSB:
2600 case R_IA64_PCREL32MSB:
2601 case R_IA64_SEGREL32MSB:
2602 case R_IA64_SECREL32MSB:
2603 case R_IA64_LTV32MSB:
2604 size = 4; bigendian = 1;
2605 break;
2606
2607 case R_IA64_DIR32LSB:
2608 case R_IA64_GPREL32LSB:
2609 case R_IA64_FPTR32LSB:
2610 case R_IA64_PCREL32LSB:
2611 case R_IA64_SEGREL32LSB:
2612 case R_IA64_SECREL32LSB:
2613 case R_IA64_LTV32LSB:
2614 size = 4; bigendian = 0;
2615 break;
2616
2617 case R_IA64_DIR64MSB:
2618 case R_IA64_GPREL64MSB:
2619 case R_IA64_PLTOFF64MSB:
2620 case R_IA64_FPTR64MSB:
2621 case R_IA64_PCREL64MSB:
2622 case R_IA64_LTOFF_FPTR64MSB:
2623 case R_IA64_SEGREL64MSB:
2624 case R_IA64_SECREL64MSB:
2625 case R_IA64_LTV64MSB:
2626 size = 8; bigendian = 1;
2627 break;
2628
2629 case R_IA64_DIR64LSB:
2630 case R_IA64_GPREL64LSB:
2631 case R_IA64_PLTOFF64LSB:
2632 case R_IA64_FPTR64LSB:
2633 case R_IA64_PCREL64LSB:
2634 case R_IA64_LTOFF_FPTR64LSB:
2635 case R_IA64_SEGREL64LSB:
2636 case R_IA64_SECREL64LSB:
2637 case R_IA64_LTV64LSB:
2638 size = 8; bigendian = 0;
2639 break;
2640
2641 /* Unsupported / Dynamic relocations. */
2642
2643 case R_IA64_REL32MSB:
2644 case R_IA64_REL32LSB:
2645 case R_IA64_REL64MSB:
2646 case R_IA64_REL64LSB:
2647
2648 case R_IA64_IPLTMSB:
2649 case R_IA64_IPLTLSB:
2650 case R_IA64_EPLTMSB:
2651 case R_IA64_EPLTLSB:
2652 case R_IA64_COPY:
2653
2654 case R_IA64_SEGBASE:
2655
2656 case R_IA64_TPREL22:
2657 case R_IA64_TPREL64MSB:
2658 case R_IA64_TPREL64LSB:
2659 case R_IA64_LTOFF_TP22:
2660
2661 default:
2662 return bfd_reloc_notsupported;
2663 }
2664
2665 switch (opnd)
2666 {
2667 case IA64_OPND_IMMU64:
2668 hit_addr -= (long) hit_addr & 0x3;
2669 t0 = bfd_get_64 (abfd, hit_addr);
2670 t1 = bfd_get_64 (abfd, hit_addr + 8);
2671
2672 /* tmpl/s: bits 0.. 5 in t0
2673 slot 0: bits 5..45 in t0
2674 slot 1: bits 46..63 in t0, bits 0..22 in t1
2675 slot 2: bits 23..63 in t1 */
2676
2677 /* First, clear the bits that form the 64 bit constant. */
2678 t0 &= ~(0x3ffffLL << 46);
2679 t1 &= ~(0x7fffffLL
2680 | (( (0x07fLL << 13) | (0x1ffLL << 27)
2681 | (0x01fLL << 22) | (0x001LL << 21)
2682 | (0x001LL << 36)) << 23));
2683
2684 t0 |= ((val >> 22) & 0x03ffffLL) << 46; /* 18 lsbs of imm41 */
2685 t1 |= ((val >> 40) & 0x7fffffLL) << 0; /* 23 msbs of imm41 */
2686 t1 |= ( (((val >> 0) & 0x07f) << 13) /* imm7b */
2687 | (((val >> 7) & 0x1ff) << 27) /* imm9d */
2688 | (((val >> 16) & 0x01f) << 22) /* imm5c */
2689 | (((val >> 21) & 0x001) << 21) /* ic */
2690 | (((val >> 63) & 0x001) << 36)) << 23; /* i */
2691
2692 bfd_put_64 (abfd, t0, hit_addr);
2693 bfd_put_64 (abfd, t1, hit_addr + 8);
2694 break;
2695
748abff6
RH		 2696 case IA64_OPND_TGT64:
2697 hit_addr -= (long) hit_addr & 0x3;
2698 t0 = bfd_get_64 (abfd, hit_addr);
2699 t1 = bfd_get_64 (abfd, hit_addr + 8);
2700
2701 /* tmpl/s: bits 0.. 5 in t0
2702 slot 0: bits 5..45 in t0
2703 slot 1: bits 46..63 in t0, bits 0..22 in t1
2704 slot 2: bits 23..63 in t1 */
2705
2706 /* First, clear the bits that form the 64 bit constant. */
2707 t0 &= ~(0x3ffffLL << 46);
2708 t1 &= ~(0x7fffffLL
2709 | ((1LL << 36 | 0xfffffLL << 13) << 23));
2710
2711 val >>= 4;
2712 t0 |= ((val >> 20) & 0xffffLL) << 2 << 46; /* 16 lsbs of imm39 */
2713 t1 |= ((val >> 36) & 0x7fffffLL) << 0; /* 23 msbs of imm39 */
2714 t1 |= ((((val >> 0) & 0xfffffLL) << 13) /* imm20b */
2715 | (((val >> 59) & 0x1LL) << 36)) << 23; /* i */
2716
2717 bfd_put_64 (abfd, t0, hit_addr);
2718 bfd_put_64 (abfd, t1, hit_addr + 8);
2719 break;
2720
800eeca4
JW		 2721 default:
2722 switch ((long) hit_addr & 0x3)
2723 {
2724 case 0: shift = 5; break;
2725 case 1: shift = 14; hit_addr += 3; break;
2726 case 2: shift = 23; hit_addr += 6; break;
2727 case 3: return bfd_reloc_notsupported; /* shouldn't happen... */
2728 }
2729 dword = bfd_get_64 (abfd, hit_addr);
2730 insn = (dword >> shift) & 0x1ffffffffffLL;
2731
2732 op = elf64_ia64_operands + opnd;
2733 err = (*op->insert) (op, val, &insn);
2734 if (err)
2735 return bfd_reloc_overflow;
2736
2737 dword &= ~(0x1ffffffffffLL << shift);
2738 dword |= (insn << shift);
2739 bfd_put_64 (abfd, dword, hit_addr);
2740 break;
2741
2742 case IA64_OPND_NIL:
2743 /* A data relocation. */
2744 if (bigendian)
2745 if (size == 4)
2746 bfd_putb32 (val, hit_addr);
2747 else
2748 bfd_putb64 (val, hit_addr);
2749 else
2750 if (size == 4)
2751 bfd_putl32 (val, hit_addr);
2752 else
2753 bfd_putl64 (val, hit_addr);
2754 break;
2755 }
2756
2757 return bfd_reloc_ok;
2758}
2759
2760static void
2761elf64_ia64_install_dyn_reloc (abfd, info, sec, srel, offset, type,
2762 dynindx, addend)
2763 bfd *abfd;
2764 struct bfd_link_info *info;
2765 asection *sec;
2766 asection *srel;
2767 bfd_vma offset;
2768 unsigned int type;
2769 long dynindx;
2770 bfd_vma addend;
2771{
2772 Elf_Internal_Rela outrel;
2773
2774 outrel.r_offset = (sec->output_section->vma
2775 + sec->output_offset
2776 + offset);
2777
2778 BFD_ASSERT (dynindx != -1);
2779 outrel.r_info = ELF64_R_INFO (dynindx, type);
2780 outrel.r_addend = addend;
2781
2782 if (elf_section_data (sec)->stab_info != NULL)
2783 {
2784 /* This may be NULL for linker-generated relocations, as it is
2785 inconvenient to pass all the bits around. And this shouldn't
2786 happen. */
2787 BFD_ASSERT (info != NULL);
2788
2789 offset = (_bfd_stab_section_offset
2790 (abfd, &elf_hash_table (info)->stab_info, sec,
2791 &elf_section_data (sec)->stab_info, offset));
2792 if (offset == (bfd_vma) -1)
2793 {
2794 /* Run for the hills. We shouldn't be outputting a relocation
2795 for this. So do what everyone else does and output a no-op. */
2796 outrel.r_info = ELF64_R_INFO (0, R_IA64_NONE);
2797 outrel.r_addend = 0;
2798 offset = 0;
2799 }
2800 outrel.r_offset = offset;
2801 }
2802
2803 bfd_elf64_swap_reloca_out (abfd, &outrel,
2804 ((Elf64_External_Rela *) srel->contents
2805 + srel->reloc_count++));
2806 BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
2807 <= srel->_cooked_size);
2808}
2809
2810/* Store an entry for target address TARGET_ADDR in the linkage table
2811 and return the gp-relative address of the linkage table entry. */
2812
2813static bfd_vma
2814set_got_entry (abfd, info, dyn_i, dynindx, addend, value, dyn_r_type)
2815 bfd *abfd;
2816 struct bfd_link_info *info;
2817 struct elf64_ia64_dyn_sym_info *dyn_i;
2818 long dynindx;
2819 bfd_vma addend;
2820 bfd_vma value;
2821 unsigned int dyn_r_type;
2822{
2823 struct elf64_ia64_link_hash_table *ia64_info;
2824 asection *got_sec;
2825
2826 ia64_info = elf64_ia64_hash_table (info);
2827 got_sec = ia64_info->got_sec;
2828
2829 BFD_ASSERT ((dyn_i->got_offset & 7) == 0);
2830
2831 if (! dyn_i->got_done)
2832 {
2833 dyn_i->got_done = true;
2834
2835 /* Store the target address in the linkage table entry. */
2836 bfd_put_64 (abfd, value, got_sec->contents + dyn_i->got_offset);
2837
2838 /* Install a dynamic relocation if needed. */
2839 if (info->shared
2840 || elf64_ia64_dynamic_symbol_p (dyn_i->h, info)
2841 || (dynindx != -1 && dyn_r_type == R_IA64_FPTR64LSB))
2842 {
2843 if (dynindx == -1)
2844 {
2845 dyn_r_type = R_IA64_REL64LSB;
2846 dynindx = 0;
2847 addend = value;
2848 }
2849
2850 if (bfd_big_endian (abfd))
2851 {
2852 switch (dyn_r_type)
2853 {
2854 case R_IA64_REL64LSB:
2855 dyn_r_type = R_IA64_REL64MSB;
2856 break;
2857 case R_IA64_DIR64LSB:
2858 dyn_r_type = R_IA64_DIR64MSB;
2859 break;
2860 case R_IA64_FPTR64LSB:
2861 dyn_r_type = R_IA64_FPTR64MSB;
2862 break;
2863 default:
2864 BFD_ASSERT (false);
2865 break;
2866 }
2867 }
2868
2869 elf64_ia64_install_dyn_reloc (abfd, NULL, got_sec,
2870 ia64_info->rel_got_sec,
2871 dyn_i->got_offset, dyn_r_type,
2872 dynindx, addend);
2873 }
2874 }
2875
2876 /* Return the address of the linkage table entry. */
2877 value = (got_sec->output_section->vma
2878 + got_sec->output_offset
2879 + dyn_i->got_offset);
2880
2881 return value;
2882}
2883
2884/* Fill in a function descriptor consisting of the function's code
2885 address and its global pointer. Return the descriptor's address. */
2886
2887static bfd_vma
2888set_fptr_entry (abfd, info, dyn_i, value)
2889 bfd *abfd;
2890 struct bfd_link_info *info;
2891 struct elf64_ia64_dyn_sym_info *dyn_i;
2892 bfd_vma value;
2893{
2894 struct elf64_ia64_link_hash_table *ia64_info;
2895 asection *fptr_sec;
2896
2897 ia64_info = elf64_ia64_hash_table (info);
2898 fptr_sec = ia64_info->fptr_sec;
2899
2900 if (!dyn_i->fptr_done)
2901 {
2902 dyn_i->fptr_done = 1;
2903
2904 /* Fill in the function descriptor. */
2905 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
2906 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
2907 fptr_sec->contents + dyn_i->fptr_offset + 8);
2908 }
2909
2910 /* Return the descriptor's address. */
2911 value = (fptr_sec->output_section->vma
2912 + fptr_sec->output_offset
2913 + dyn_i->fptr_offset);
2914
2915 return value;
2916}
2917
2918/* Fill in a PLTOFF entry consisting of the function's code address
2919 and its global pointer. Return the descriptor's address. */
2920
2921static bfd_vma
2922set_pltoff_entry (abfd, info, dyn_i, value, is_plt)
2923 bfd *abfd;
2924 struct bfd_link_info *info;
2925 struct elf64_ia64_dyn_sym_info *dyn_i;
2926 bfd_vma value;
2927 boolean is_plt;
2928{
2929 struct elf64_ia64_link_hash_table *ia64_info;
2930 asection *pltoff_sec;
2931
2932 ia64_info = elf64_ia64_hash_table (info);
2933 pltoff_sec = ia64_info->pltoff_sec;
2934
2935 /* Don't do anything if this symbol uses a real PLT entry. In
2936 that case, we'll fill this in during finish_dynamic_symbol. */
2937 if ((! dyn_i->want_plt || is_plt)
2938 && !dyn_i->pltoff_done)
2939 {
2940 /* Fill in the function descriptor. */
2941 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
2942 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
2943 pltoff_sec->contents + dyn_i->pltoff_offset + 8);
2944
2945 /* Install dynamic relocations if needed. */
2946 if (!is_plt && info->shared)
2947 {
2948 unsigned int dyn_r_type;
2949
2950 if (bfd_big_endian (abfd))
2951 dyn_r_type = R_IA64_REL64MSB;
2952 else
2953 dyn_r_type = R_IA64_REL64LSB;
2954
2955 elf64_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
2956 ia64_info->rel_pltoff_sec,
2957 dyn_i->pltoff_offset,
2958 dyn_r_type, 0, 0);
2959 elf64_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
2960 ia64_info->rel_pltoff_sec,
2961 dyn_i->pltoff_offset + 8,
2962 dyn_r_type, 0, 0);
2963 }
2964
2965 dyn_i->pltoff_done = 1;
2966 }
2967
2968 /* Return the descriptor's address. */
2969 value = (pltoff_sec->output_section->vma
2970 + pltoff_sec->output_offset
2971 + dyn_i->pltoff_offset);
2972
2973 return value;
2974}
2975
2976static boolean
2977elf64_ia64_final_link (abfd, info)
2978 bfd *abfd;
2979 struct bfd_link_info *info;
2980{
2981 struct elf64_ia64_link_hash_table *ia64_info;
2982 ia64_info = elf64_ia64_hash_table (info);
2983
2984 /* Make sure we've got ourselves a nice fat __gp value. */
2985 if (!info->relocateable)
2986 {
2987 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
2988 bfd_vma min_short_vma = min_vma, max_short_vma = 0;
2989 struct elf_link_hash_entry *gp;
2990 bfd_vma gp_val;
2991 asection *os;
2992
2993 /* Find the min and max vma of all sections marked short. Also
2994 collect min and max vma of any type, for use in selecting a
2995 nice gp. */
2996 for (os = abfd->sections; os ; os = os->next)
2997 {
2998 bfd_vma lo, hi;
2999
3000 if ((os->flags & SEC_ALLOC) == 0)
3001 continue;
3002
3003 lo = os->vma;
3004 hi = os->vma + os->_raw_size;
3005 if (hi < lo)
3006 hi = (bfd_vma) -1;
3007
3008 if (min_vma > lo)
3009 min_vma = lo;
3010 if (max_vma < hi)
3011 max_vma = hi;
3012 if (os->flags & SEC_SMALL_DATA)
3013 {
3014 if (min_short_vma > lo)
3015 min_short_vma = lo;
3016 if (max_short_vma < hi)
3017 max_short_vma = hi;
3018 }
3019 }
3020
3021 /* See if the user wants to force a value. */
3022 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false,
3023 false, false);
3024
3025 if (gp
3026 && (gp->root.type == bfd_link_hash_defined
3027 || gp->root.type == bfd_link_hash_defweak))
3028 {
3029 asection *gp_sec = gp->root.u.def.section;
3030 gp_val = (gp->root.u.def.value
3031 + gp_sec->output_section->vma
3032 + gp_sec->output_offset);
3033 }
3034 else
3035 {
3036 /* Pick a sensible value. */
3037
3038 asection *got_sec = ia64_info->got_sec;
3039
3040 /* Start with just the address of the .got. */
3041 if (got_sec)
3042 gp_val = got_sec->output_section->vma;
3043 else if (max_short_vma != 0)
3044 gp_val = min_short_vma;
3045 else
3046 gp_val = min_vma;
3047
3048 /* If it is possible to address the entire image, but we
3049 don't with the choice above, adjust. */
3050 if (max_vma - min_vma < 0x400000
3051 && max_vma - gp_val <= 0x200000
3052 && gp_val - min_vma > 0x200000)
3053 gp_val = min_vma + 0x200000;
3054 else if (max_short_vma != 0)
3055 {
3056 /* If we don't cover all the short data, adjust. */
3057 if (max_short_vma - gp_val >= 0x200000)
3058 gp_val = min_short_vma + 0x200000;
3059
3060 /* If we're addressing stuff past the end, adjust back. */
3061 if (gp_val > max_vma)
3062 gp_val = max_vma - 0x200000 + 8;
3063 }
3064 }
3065
3066 /* Validate whether all SHF_IA_64_SHORT sections are within
3067 range of the chosen GP. */
3068
3069 if (max_short_vma != 0)
3070 {
3071 if (max_short_vma - min_short_vma >= 0x400000)
3072 {
3073 (*_bfd_error_handler)
3074 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3075 bfd_get_filename (abfd),
3076 (unsigned long)(max_short_vma - min_short_vma));
3077 return false;
3078 }
3079 else if ((gp_val > min_short_vma
3080 && gp_val - min_short_vma > 0x200000)
3081 || (gp_val < max_short_vma
3082 && max_short_vma - gp_val >= 0x200000))
3083 {
3084 (*_bfd_error_handler)
3085 (_("%s: __gp does not cover short data segment"),
3086 bfd_get_filename (abfd));
3087 return false;
3088 }
3089 }
3090
3091 _bfd_set_gp_value (abfd, gp_val);
3092 }
3093
3094 /* Tricky bits. DT_INIT and DT_FINI use a pltoff entry, which is
3095 normally initialized in finish_dynamic_sections. Except that
3096 we need all non-plt pltoff entries to be initialized before
3097 finish_dynamic_symbols. This because the array of relocations
3098 used for plt entries (aka DT_JMPREL) begins after all the
3099 non-plt pltoff relocations. If the order gets confused, we
3100 munge either the array or the array base. */
3101 if (ia64_info->root.dynamic_sections_created)
3102 {
3103 struct elf_link_hash_entry *h;
3104 struct elf64_ia64_dyn_sym_info *dyn_i;
3105 bfd_vma addr;
3106
3107 if (info->init_function
3108 && (h = elf_link_hash_lookup (elf_hash_table (info),
3109 info->init_function, false,
3110 false, false))
3111 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
3112 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
3113 {
3114 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
3115 addr = (h->root.u.def.section->output_section->vma
3116 + h->root.u.def.section->output_offset
3117 + h->root.u.def.value);
3118 (void) set_pltoff_entry (abfd, info, dyn_i, addr, false);
3119 }
3120
3121 if (info->fini_function
3122 && (h = elf_link_hash_lookup (elf_hash_table (info),
3123 info->fini_function, false,
3124 false, false))
3125 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
3126 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
3127 {
3128 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
3129 addr = (h->root.u.def.section->output_section->vma
3130 + h->root.u.def.section->output_offset
3131 + h->root.u.def.value);
3132 (void) set_pltoff_entry (abfd, info, dyn_i, addr, false);
3133 }
3134 }
3135
3136 /* Invoke the regular ELF backend linker to do all the work. */
3137 return bfd_elf64_bfd_final_link (abfd, info);
3138}
3139
3140static boolean
3141elf64_ia64_relocate_section (output_bfd, info, input_bfd, input_section,
3142 contents, relocs, local_syms, local_sections)
3143 bfd *output_bfd;
3144 struct bfd_link_info *info;
3145 bfd *input_bfd;
3146 asection *input_section;
3147 bfd_byte *contents;
3148 Elf_Internal_Rela *relocs;
3149 Elf_Internal_Sym *local_syms;
3150 asection **local_sections;
3151{
3152 struct elf64_ia64_link_hash_table *ia64_info;
3153 Elf_Internal_Shdr *symtab_hdr;
3154 Elf_Internal_Rela *rel;
3155 Elf_Internal_Rela *relend;
3156 asection *srel;
3157 boolean ret_val = true; /* for non-fatal errors */
3158 bfd_vma gp_val;
3159
3160 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3161 ia64_info = elf64_ia64_hash_table (info);
3162
3163 /* Infect various flags from the input section to the output section. */
3164 if (info->relocateable)
3165 {
3166 bfd_vma flags;
3167
3168 flags = elf_section_data(input_section)->this_hdr.sh_flags;
3169 flags &= SHF_IA_64_NORECOV;
3170
3171 elf_section_data(input_section->output_section)
3172 ->this_hdr.sh_flags |= flags;
3173 }
3174
3175 gp_val = _bfd_get_gp_value (output_bfd);
3176 srel = get_reloc_section (input_bfd, ia64_info, input_section, false);
3177
3178 rel = relocs;
3179 relend = relocs + input_section->reloc_count;
3180 for (; rel < relend; ++rel)
3181 {
3182 struct elf_link_hash_entry *h;
3183 struct elf64_ia64_dyn_sym_info *dyn_i;
3184 bfd_reloc_status_type r;
3185 reloc_howto_type *howto;
3186 unsigned long r_symndx;
3187 Elf_Internal_Sym *sym;
3188 unsigned int r_type;
3189 bfd_vma value;
3190 asection *sym_sec;
3191 bfd_byte *hit_addr;
3192 boolean dynamic_symbol_p;
3193 boolean undef_weak_ref;
3194
3195 r_type = ELF64_R_TYPE (rel->r_info);
3196 if (r_type > R_IA64_MAX_RELOC_CODE)
3197 {
3198 (*_bfd_error_handler)
3199 (_("%s: unknown relocation type %d"),
3200 bfd_get_filename (input_bfd), (int)r_type);
3201 bfd_set_error (bfd_error_bad_value);
3202 ret_val = false;
3203 continue;
3204 }
3205 howto = lookup_howto (r_type);
3206 r_symndx = ELF64_R_SYM (rel->r_info);
3207
3208 if (info->relocateable)
3209 {
3210 /* This is a relocateable link. We don't have to change
3211 anything, unless the reloc is against a section symbol,
3212 in which case we have to adjust according to where the
3213 section symbol winds up in the output section. */
3214 if (r_symndx < symtab_hdr->sh_info)
3215 {
3216 sym = local_syms + r_symndx;
3217 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3218 {
3219 sym_sec = local_sections[r_symndx];
3220 rel->r_addend += sym_sec->output_offset;
3221 }
3222 }
3223 continue;
3224 }
3225
3226 /* This is a final link. */
3227
3228 h = NULL;
3229 sym = NULL;
3230 sym_sec = NULL;
3231 undef_weak_ref = false;
3232
3233 if (r_symndx < symtab_hdr->sh_info)
3234 {
3235 /* Reloc against local symbol. */
3236 sym = local_syms + r_symndx;
3237 sym_sec = local_sections[r_symndx];
3238 value = (sym_sec->output_section->vma
3239 + sym_sec->output_offset
3240 + sym->st_value);
3241 }
3242 else
3243 {
3244 long indx;
3245
3246 /* Reloc against global symbol. */
3247 indx = r_symndx - symtab_hdr->sh_info;
3248 h = elf_sym_hashes (input_bfd)[indx];
3249 while (h->root.type == bfd_link_hash_indirect
3250 || h->root.type == bfd_link_hash_warning)
3251 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3252
3253 value = 0;
3254 if (h->root.type == bfd_link_hash_defined
3255 || h->root.type == bfd_link_hash_defweak)
3256 {
3257 sym_sec = h->root.u.def.section;
3258
3259 /* Detect the cases that sym_sec->output_section is
3260 expected to be NULL -- all cases in which the symbol
3261 is defined in another shared module. This includes
3262 PLT relocs for which we've created a PLT entry and
3263 other relocs for which we're prepared to create
3264 dynamic relocations. */
3265 /* ??? Just accept it NULL and continue. */
3266
3267 if (sym_sec->output_section != NULL)
3268 {
3269 value = (h->root.u.def.value
3270 + sym_sec->output_section->vma
3271 + sym_sec->output_offset);
3272 }
3273 }
3274 else if (h->root.type == bfd_link_hash_undefweak)
3275 undef_weak_ref = true;
3a27a730
L		 3276 else if (info->shared && !info->symbolic
3277 && !info->no_undefined
3278 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
800eeca4
JW		 3279 ;
3280 else
3281 {
3282 if (! ((*info->callbacks->undefined_symbol)
3283 (info, h->root.root.string, input_bfd,
3284 input_section, rel->r_offset,
3a27a730
L		 3285 (!info->shared || info->no_undefined
3286 || ELF_ST_VISIBILITY (h->other)))))
800eeca4
JW		 3287 return false;
3288 ret_val = false;
3289 continue;
3290 }
3291 }
3292
3293 hit_addr = contents + rel->r_offset;
3294 value += rel->r_addend;
3295 dynamic_symbol_p = elf64_ia64_dynamic_symbol_p (h, info);
3296
3297 switch (r_type)
3298 {
3299 case R_IA64_NONE:
3300 case R_IA64_LDXMOV:
3301 continue;
3302
3303 case R_IA64_IMM14:
3304 case R_IA64_IMM22:
3305 case R_IA64_IMM64:
3306 case R_IA64_DIR32MSB:
3307 case R_IA64_DIR32LSB:
3308 case R_IA64_DIR64MSB:
3309 case R_IA64_DIR64LSB:
3310 /* Install a dynamic relocation for this reloc. */
3311 if ((dynamic_symbol_p || info->shared)
3312 && (input_section->flags & SEC_ALLOC) != 0)
3313 {
3314 unsigned int dyn_r_type;
3315 long dynindx;
3316
3317 BFD_ASSERT (srel != NULL);
3318
3319 /* If we don't need dynamic symbol lookup, find a
3320 matching RELATIVE relocation. */
3321 dyn_r_type = r_type;
3322 if (dynamic_symbol_p)
3323 dynindx = h->dynindx;
3324 else
3325 {
3326 switch (r_type)
3327 {
3328 case R_IA64_DIR32MSB:
3329 dyn_r_type = R_IA64_REL32MSB;
3330 break;
3331 case R_IA64_DIR32LSB:
3332 dyn_r_type = R_IA64_REL32LSB;
3333 break;
3334 case R_IA64_DIR64MSB:
3335 dyn_r_type = R_IA64_REL64MSB;
3336 break;
3337 case R_IA64_DIR64LSB:
3338 dyn_r_type = R_IA64_REL64LSB;
3339 break;
3340
3341 default:
3342 /* We can't represent this without a dynamic symbol.
3343 Adjust the relocation to be against an output
3344 section symbol, which are always present in the
3345 dynamic symbol table. */
3346 /* ??? People shouldn't be doing non-pic code in
3347 shared libraries. Hork. */
3348 (*_bfd_error_handler)
3349 (_("%s: linking non-pic code in a shared library"),
3350 bfd_get_filename (input_bfd));
3351 ret_val = false;
3352 continue;
3353 }
3354 dynindx = 0;
3355 }
3356
3357 elf64_ia64_install_dyn_reloc (output_bfd, info, input_section,
3358 srel, rel->r_offset, dyn_r_type,
3359 dynindx, rel->r_addend);
3360 }
3361 /* FALLTHRU */
3362
3363 case R_IA64_LTV32MSB:
3364 case R_IA64_LTV32LSB:
3365 case R_IA64_LTV64MSB:
3366 case R_IA64_LTV64LSB:
3367 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3368 break;
3369
3370 case R_IA64_GPREL22:
3371 case R_IA64_GPREL64I:
3372 case R_IA64_GPREL32MSB:
3373 case R_IA64_GPREL32LSB:
3374 case R_IA64_GPREL64MSB:
3375 case R_IA64_GPREL64LSB:
3376 if (dynamic_symbol_p)
3377 {
3378 (*_bfd_error_handler)
3379 (_("%s: @gprel relocation against dynamic symbol %s"),
3380 bfd_get_filename (input_bfd), h->root.root.string);
3381 ret_val = false;
3382 continue;
3383 }
3384 value -= gp_val;
3385 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3386 break;
3387
3388 case R_IA64_LTOFF22:
3389 case R_IA64_LTOFF22X:
3390 case R_IA64_LTOFF64I:
3391 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3392 value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
3393 rel->r_addend, value, R_IA64_DIR64LSB);
3394 value -= gp_val;
3395 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3396 break;
3397
3398 case R_IA64_PLTOFF22:
3399 case R_IA64_PLTOFF64I:
3400 case R_IA64_PLTOFF64MSB:
3401 case R_IA64_PLTOFF64LSB:
3402 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3403 value = set_pltoff_entry (output_bfd, info, dyn_i, value, false);
3404 value -= gp_val;
3405 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3406 break;
3407
3408 case R_IA64_FPTR64I:
3409 case R_IA64_FPTR32MSB:
3410 case R_IA64_FPTR32LSB:
3411 case R_IA64_FPTR64MSB:
3412 case R_IA64_FPTR64LSB:
3413 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3414 if (dyn_i->want_fptr)
3415 {
3416 if (!undef_weak_ref)
3417 value = set_fptr_entry (output_bfd, info, dyn_i, value);
3418 }
3419 else
3420 {
3421 long dynindx;
3422
3423 /* Otherwise, we expect the dynamic linker to create
3424 the entry. */
3425
3426 if (h)
3427 {
3428 if (h->dynindx != -1)
3429 dynindx = h->dynindx;
3430 else
3431 dynindx = (_bfd_elf_link_lookup_local_dynindx
3432 (info, h->root.u.def.section->owner,
3433 global_sym_index (h)));
3434 }
3435 else
3436 {
3437 dynindx = (_bfd_elf_link_lookup_local_dynindx
3438 (info, input_bfd, r_symndx));
3439 }
3440
3441 elf64_ia64_install_dyn_reloc (output_bfd, info, input_section,
3442 srel, rel->r_offset, r_type,
3443 dynindx, rel->r_addend);
3444 value = 0;
3445 }
3446
3447 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3448 break;
3449
3450 case R_IA64_LTOFF_FPTR22:
3451 case R_IA64_LTOFF_FPTR64I:
3452 case R_IA64_LTOFF_FPTR64MSB:
3453 case R_IA64_LTOFF_FPTR64LSB:
3454 {
3455 long dynindx;
3456
3457 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3458 if (dyn_i->want_fptr)
3459 {
3460 BFD_ASSERT (h == NULL || h->dynindx == -1)
3461 if (!undef_weak_ref)
3462 value = set_fptr_entry (output_bfd, info, dyn_i, value);
3463 dynindx = -1;
3464 }
3465 else
3466 {
3467 /* Otherwise, we expect the dynamic linker to create
3468 the entry. */
3469 if (h)
3470 {
3471 if (h->dynindx != -1)
3472 dynindx = h->dynindx;
3473 else
3474 dynindx = (_bfd_elf_link_lookup_local_dynindx
3475 (info, h->root.u.def.section->owner,
3476 global_sym_index (h)));
3477 }
3478 else
3479 dynindx = (_bfd_elf_link_lookup_local_dynindx
3480 (info, input_bfd, r_symndx));
3481 value = 0;
3482 }
3483
3484 value = set_got_entry (output_bfd, info, dyn_i, dynindx,
3485 rel->r_addend, value, R_IA64_FPTR64LSB);
3486 value -= gp_val;
3487 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3488 }
3489 break;
3490
3491 case R_IA64_PCREL32MSB:
3492 case R_IA64_PCREL32LSB:
3493 case R_IA64_PCREL64MSB:
3494 case R_IA64_PCREL64LSB:
3495 /* Install a dynamic relocation for this reloc. */
3496 if (dynamic_symbol_p)
3497 {
3498 BFD_ASSERT (srel != NULL);
3499
3500 elf64_ia64_install_dyn_reloc (output_bfd, info, input_section,
3501 srel, rel->r_offset, r_type,
3502 h->dynindx, rel->r_addend);
3503 }
3504 goto finish_pcrel;
3505
748abff6 3506 case R_IA64_PCREL21BI:
800eeca4
JW		 3507 case R_IA64_PCREL21F:
3508 case R_IA64_PCREL21M:
3509 /* ??? These two are only used for speculation fixup code.
3510 They should never be dynamic. */
3511 if (dynamic_symbol_p)
3512 {
3513 (*_bfd_error_handler)
3514 (_("%s: dynamic relocation against speculation fixup"),
3515 bfd_get_filename (input_bfd));
3516 ret_val = false;
3517 continue;
3518 }
3519 if (undef_weak_ref)
3520 {
3521 (*_bfd_error_handler)
3522 (_("%s: speculation fixup against undefined weak symbol"),
3523 bfd_get_filename (input_bfd));
3524 ret_val = false;
3525 continue;
3526 }
3527 goto finish_pcrel;
3528
3529 case R_IA64_PCREL21B:
748abff6 3530 case R_IA64_PCREL60B:
800eeca4 3531 /* We should have created a PLT entry for any dynamic symbol. */
800eeca4
JW		 3532 dyn_i = NULL;
3533 if (h)
3534 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
3535
3536 if (dyn_i && dyn_i->want_plt2)
3537 {
3538 /* Should have caught this earlier. */
3539 BFD_ASSERT (rel->r_addend == 0);
3540
3541 value = (ia64_info->plt_sec->output_section->vma
3542 + ia64_info->plt_sec->output_offset
3543 + dyn_i->plt2_offset);
3544 }
3545 else
3546 {
3547 /* Since there's no PLT entry, Validate that this is
3548 locally defined. */
3549 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
3550
3551 /* If the symbol is undef_weak, we shouldn't be trying
3552 to call it. There's every chance that we'd wind up
3553 with an out-of-range fixup here. Don't bother setting
3554 any value at all. */
3555 if (undef_weak_ref)
3556 continue;
3557 }
3558 goto finish_pcrel;
3559
748abff6
RH		 3560 case R_IA64_PCREL22:
3561 case R_IA64_PCREL64I:
800eeca4
JW		 3562 finish_pcrel:
3563 /* Make pc-relative. */
3564 value -= (input_section->output_section->vma
3565 + input_section->output_offset
3566 + rel->r_offset) & ~ (bfd_vma) 0x3;
3567 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3568 break;
3569
3570 case R_IA64_SEGREL32MSB:
3571 case R_IA64_SEGREL32LSB:
3572 case R_IA64_SEGREL64MSB:
3573 case R_IA64_SEGREL64LSB:
3574 {
3575 struct elf_segment_map *m;
3576 Elf_Internal_Phdr *p;
3577
3578 /* Find the segment that contains the output_section. */
3579 for (m = elf_tdata (output_bfd)->segment_map,
3580 p = elf_tdata (output_bfd)->phdr;
3581 m != NULL;
3582 m = m->next, p++)
3583 {
3584 int i;
3585 for (i = m->count - 1; i >= 0; i--)
3586 if (m->sections[i] == sym_sec->output_section)
3587 break;
3588 if (i >= 0)
3589 break;
3590 }
3591
3592 if (m == NULL)
3593 {
3594 /* If the input section was discarded from the output, then
3595 do nothing. */
3596
3597 if (bfd_is_abs_section (sym_sec->output_section))
3598 r = bfd_reloc_ok;
3599 else
3600 r = bfd_reloc_notsupported;
3601 }
3602 else
3603 {
3604 /* The VMA of the segment is the vaddr of the associated
3605 program header. */
3606 if (value > p->p_vaddr)
3607 value -= p->p_vaddr;
3608 else
3609 value = 0;
3610 r = elf64_ia64_install_value (output_bfd, hit_addr, value,
3611 r_type);
3612 }
3613 break;
3614 }
3615
3616 case R_IA64_SECREL32MSB:
3617 case R_IA64_SECREL32LSB:
3618 case R_IA64_SECREL64MSB:
3619 case R_IA64_SECREL64LSB:
3620 /* Make output-section relative. */
3621 if (value > input_section->output_section->vma)
3622 value -= input_section->output_section->vma;
3623 else
3624 value = 0;
3625 r = elf64_ia64_install_value (output_bfd, hit_addr, value, r_type);
3626 break;
3627
3628 case R_IA64_SEGBASE:
3629
3630 case R_IA64_REL32MSB:
3631 case R_IA64_REL32LSB:
3632 case R_IA64_REL64MSB:
3633 case R_IA64_REL64LSB:
3634
3635 case R_IA64_IPLTMSB:
3636 case R_IA64_IPLTLSB:
3637 case R_IA64_EPLTMSB:
3638 case R_IA64_EPLTLSB:
3639 case R_IA64_COPY:
3640
3641 case R_IA64_TPREL22:
3642 case R_IA64_TPREL64MSB:
3643 case R_IA64_TPREL64LSB:
3644 case R_IA64_LTOFF_TP22:
3645 default:
3646 r = bfd_reloc_notsupported;
3647 break;
3648 }
3649
3650 switch (r)
3651 {
3652 case bfd_reloc_ok:
3653 break;
3654
3655 case bfd_reloc_undefined:
3656 /* This can happen for global table relative relocs if
3657 __gp is undefined. This is a panic situation so we
3658 don't try to continue. */
3659 (*info->callbacks->undefined_symbol)
3660 (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
3661 return false;
3662
3663 case bfd_reloc_notsupported:
3664 {
3665 const char *name;
3666
3667 if (h)
3668 name = h->root.root.string;
3669 else
3670 {
3671 name = bfd_elf_string_from_elf_section (input_bfd,
3672 symtab_hdr->sh_link,
3673 sym->st_name);
3674 if (name == NULL)
3675 return false;
3676 if (*name == '\0')
3677 name = bfd_section_name (input_bfd, input_section);
3678 }
3679 if (!(*info->callbacks->warning) (info, _("unsupported reloc"),
3680 name, input_bfd,
3681 input_section, rel->r_offset))
3682 return false;
3683 ret_val = false;
3684 }
3685 break;
3686
3687 case bfd_reloc_dangerous:
3688 case bfd_reloc_outofrange:
3689 case bfd_reloc_overflow:
3690 default:
3691 {
3692 const char *name;
3693
3694 if (h)
3695 name = h->root.root.string;
3696 else
3697 {
3698 name = bfd_elf_string_from_elf_section (input_bfd,
3699 symtab_hdr->sh_link,
3700 sym->st_name);
3701 if (name == NULL)
3702 return false;
3703 if (*name == '\0')
3704 name = bfd_section_name (input_bfd, input_section);
3705 }
3706 if (!(*info->callbacks->reloc_overflow) (info, name,
3707 howto->name, 0,
3708 input_bfd,
3709 input_section,
3710 rel->r_offset))
3711 return false;
3712 ret_val = false;
3713 }
3714 break;
3715 }
3716 }
3717
3718 return ret_val;
3719}
3720
3721static boolean
3722elf64_ia64_finish_dynamic_symbol (output_bfd, info, h, sym)
3723 bfd *output_bfd;
3724 struct bfd_link_info *info;
3725 struct elf_link_hash_entry *h;
3726 Elf_Internal_Sym *sym;
3727{
3728 struct elf64_ia64_link_hash_table *ia64_info;
3729 struct elf64_ia64_dyn_sym_info *dyn_i;
3730
3731 ia64_info = elf64_ia64_hash_table (info);
3732 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
3733
3734 /* Fill in the PLT data, if required. */
3735 if (dyn_i && dyn_i->want_plt)
3736 {
3737 Elf_Internal_Rela outrel;
3738 bfd_byte *loc;
3739 asection *plt_sec;
3740 bfd_vma plt_addr, pltoff_addr, gp_val, index;
3741 Elf64_External_Rela *rel;
3742
3743 gp_val = _bfd_get_gp_value (output_bfd);
3744
3745 /* Initialize the minimal PLT entry. */
3746
3747 index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
3748 plt_sec = ia64_info->plt_sec;
3749 loc = plt_sec->contents + dyn_i->plt_offset;
3750
3751 memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
3752 elf64_ia64_install_value (output_bfd, loc, index, R_IA64_IMM22);
3753 elf64_ia64_install_value (output_bfd, loc+2, -dyn_i->plt_offset,
3754 R_IA64_PCREL21B);
3755
3756 plt_addr = (plt_sec->output_section->vma
3757 + plt_sec->output_offset
3758 + dyn_i->plt_offset);
3759 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, true);
3760
3761 /* Initialize the FULL PLT entry, if needed. */
3762 if (dyn_i->want_plt2)
3763 {
3764 loc = plt_sec->contents + dyn_i->plt2_offset;
3765
3766 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
3767 elf64_ia64_install_value (output_bfd, loc, pltoff_addr - gp_val,
3768 R_IA64_IMM22);
3769
3770 /* Mark the symbol as undefined, rather than as defined in the
3771 plt section. Leave the value alone. */
3772 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
3773 first place. But perhaps elflink.h did some for us. */
3774 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3775 sym->st_shndx = SHN_UNDEF;
3776 }
3777
3778 /* Create the dynamic relocation. */
3779 outrel.r_offset = pltoff_addr;
3780 if (bfd_little_endian (output_bfd))
3781 outrel.r_info = ELF64_R_INFO (h->dynindx, R_IA64_IPLTLSB);
3782 else
3783 outrel.r_info = ELF64_R_INFO (h->dynindx, R_IA64_IPLTMSB);
3784 outrel.r_addend = 0;
3785
3786 /* This is fun. In the .IA_64.pltoff section, we've got entries
3787 that correspond both to real PLT entries, and those that
3788 happened to resolve to local symbols but need to be created
3789 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
3790 relocations for the real PLT should come at the end of the
3791 section, so that they can be indexed by plt entry at runtime.
3792
3793 We emitted all of the relocations for the non-PLT @pltoff
3794 entries during relocate_section. So we can consider the
3795 existing sec->reloc_count to be the base of the array of
3796 PLT relocations. */
3797
3798 rel = (Elf64_External_Rela *)ia64_info->rel_pltoff_sec->contents;
3799 rel += ia64_info->rel_pltoff_sec->reloc_count;
3800
3801 bfd_elf64_swap_reloca_out (output_bfd, &outrel, rel + index);
3802 }
3803
3804 /* Mark some specially defined symbols as absolute. */
3805 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3806 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3807 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3808 sym->st_shndx = SHN_ABS;
3809
3810 return true;
3811}
3812
3813static boolean
3814elf64_ia64_finish_dynamic_sections (abfd, info)
3815 bfd *abfd;
3816 struct bfd_link_info *info;
3817{
3818 struct elf64_ia64_link_hash_table *ia64_info;
3819 bfd *dynobj;
3820
3821 ia64_info = elf64_ia64_hash_table (info);
3822 dynobj = ia64_info->root.dynobj;
3823
3824 if (elf_hash_table (info)->dynamic_sections_created)
3825 {
3826 Elf64_External_Dyn *dyncon, *dynconend;
3827 asection *sdyn, *sgotplt;
3828 bfd_vma gp_val;
3829
3830 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3831 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3832 BFD_ASSERT (sdyn != NULL);
3833 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3834 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3835
3836 gp_val = _bfd_get_gp_value (abfd);
3837
3838 for (; dyncon < dynconend; dyncon++)
3839 {
3840 Elf_Internal_Dyn dyn;
3841 const char *name;
3842 asection *s;
3843
3844 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3845
3846 switch (dyn.d_tag)
3847 {
3848 case DT_PLTGOT:
3849 dyn.d_un.d_ptr = gp_val;
3850 break;
3851
3852 case DT_PLTRELSZ:
3853 dyn.d_un.d_val = (ia64_info->minplt_entries
3854 * sizeof (Elf64_External_Rela));
3855 break;
3856
3857 case DT_JMPREL:
3858 /* See the comment above in finish_dynamic_symbol. */
3859 dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
3860 + ia64_info->rel_pltoff_sec->output_offset
3861 + (ia64_info->rel_pltoff_sec->reloc_count
3862 * sizeof (Elf64_External_Rela)));
3863 break;
3864
3865 case DT_IA_64_PLT_RESERVE:
3866 dyn.d_un.d_ptr = (sgotplt->output_section->vma
3867 + sgotplt->output_offset);
3868 break;
3869
3870 case DT_RELASZ:
3871 /* Do not have RELASZ include JMPREL. This makes things
3872 easier on ld.so. This is not what the rest of BFD set up. */
3873 dyn.d_un.d_val -= (ia64_info->minplt_entries
3874 * sizeof (Elf64_External_Rela));
3875 break;
3876
3877 case DT_INIT:
3878 case DT_FINI:
3879 {
3880 struct elf_link_hash_entry *h;
3881 struct elf64_ia64_dyn_sym_info *dyn_i;
3882 const char *which;
3883
3884 if (dyn.d_tag == DT_INIT)
3885 which = info->init_function;
3886 else
3887 which = info->fini_function;
3888
3889 h = elf_link_hash_lookup (elf_hash_table (info), which,
3890 false, false, false);
3891 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
3892 dyn.d_un.d_ptr = set_pltoff_entry (abfd, info, dyn_i,
3893 dyn.d_un.d_ptr, 0);
3894 }
3895 }
3896
3897 bfd_elf64_swap_dyn_out (abfd, &dyn, dyncon);
3898 }
3899
3900 /* Initialize the PLT0 entry */
3901 if (ia64_info->plt_sec)
3902 {
3903 bfd_byte *loc = ia64_info->plt_sec->contents;
3904 bfd_vma pltres;
3905
3906 memcpy (loc, plt_header, PLT_HEADER_SIZE);
3907
3908 pltres = (sgotplt->output_section->vma
3909 + sgotplt->output_offset
3910 - gp_val);
3911
3912 elf64_ia64_install_value (abfd, loc+1, pltres, R_IA64_GPREL22);
3913 }
3914 }
3915
3916 return true;
3917}
3918\f
3919/* ELF file flag handling: */
3920
3921/* Function to keep IA-64 specific file flags. */
3922static boolean
3923elf64_ia64_set_private_flags (abfd, flags)
3924 bfd *abfd;
3925 flagword flags;
3926{
3927 BFD_ASSERT (!elf_flags_init (abfd)
3928 || elf_elfheader (abfd)->e_flags == flags);
3929
3930 elf_elfheader (abfd)->e_flags = flags;
3931 elf_flags_init (abfd) = true;
3932 return true;
3933}
3934
3935/* Copy backend specific data from one object module to another */
3936static boolean
3937elf64_ia64_copy_private_bfd_data (ibfd, obfd)
3938 bfd *ibfd, *obfd;
3939{
3940 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3941 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3942 return true;
3943
3944 BFD_ASSERT (!elf_flags_init (obfd)
3945 || (elf_elfheader (obfd)->e_flags
3946 == elf_elfheader (ibfd)->e_flags));
3947
3948 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
3949 elf_flags_init (obfd) = true;
3950 return true;
3951}
3952
3953/* Merge backend specific data from an object file to the output
3954 object file when linking. */
3955static boolean
3956elf64_ia64_merge_private_bfd_data (ibfd, obfd)
3957 bfd *ibfd, *obfd;
3958{
3959 flagword out_flags;
3960 flagword in_flags;
3961 boolean ok = true;
3962
3963 /* Don't even pretend to support mixed-format linking. */
3964 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3965 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3966 return false;
3967
3968 in_flags = elf_elfheader (ibfd)->e_flags;
3969 out_flags = elf_elfheader (obfd)->e_flags;
3970
3971 if (! elf_flags_init (obfd))
3972 {
3973 elf_flags_init (obfd) = true;
3974 elf_elfheader (obfd)->e_flags = in_flags;
3975
3976 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3977 && bfd_get_arch_info (obfd)->the_default)
3978 {
3979 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3980 bfd_get_mach (ibfd));
3981 }
3982
3983 return true;
3984 }
3985
3986 /* Check flag compatibility. */
3987 if (in_flags == out_flags)
3988 return true;
3989
c43c2cc5
JW		 3990 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
3991 if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
3992 elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
3993
800eeca4
JW		 3994 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
3995 {
3996 (*_bfd_error_handler)
3997 (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
3998 bfd_get_filename (ibfd));
3999
4000 bfd_set_error (bfd_error_bad_value);
4001 ok = false;
4002 }
4003 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
4004 {
4005 (*_bfd_error_handler)
4006 (_("%s: linking big-endian files with little-endian files"),
4007 bfd_get_filename (ibfd));
4008
4009 bfd_set_error (bfd_error_bad_value);
4010 ok = false;
4011 }
4012 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
4013 {
4014 (*_bfd_error_handler)
4015 (_("%s: linking 64-bit files with 32-bit files"),
4016 bfd_get_filename (ibfd));
4017
4018 bfd_set_error (bfd_error_bad_value);
4019 ok = false;
4020 }
c43c2cc5
JW		 4021 if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
4022 {
4023 (*_bfd_error_handler)
4024 (_("%s: linking constant-gp files with non-constant-gp files"),
4025 bfd_get_filename (ibfd));
4026
4027 bfd_set_error (bfd_error_bad_value);
4028 ok = false;
4029 }
4030 if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
4031 != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
4032 {
4033 (*_bfd_error_handler)
4034 (_("%s: linking auto-pic files with non-auto-pic files"),
4035 bfd_get_filename (ibfd));
4036
4037 bfd_set_error (bfd_error_bad_value);
4038 ok = false;
4039 }
800eeca4
JW		 4040
4041 return ok;
4042}
4043
4044static boolean
4045elf64_ia64_print_private_bfd_data (abfd, ptr)
4046 bfd *abfd;
4047 PTR ptr;
4048{
4049 FILE *file = (FILE *) ptr;
4050 flagword flags = elf_elfheader (abfd)->e_flags;
4051
4052 BFD_ASSERT (abfd != NULL && ptr != NULL);
4053
c43c2cc5 4054 fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
800eeca4
JW		 4055 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4056 (flags & EF_IA_64_EXT) ? "EXT, " : "",
4057 (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
c43c2cc5
JW		 4058 (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
4059 (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
4060 (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
4061 (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
800eeca4 4062 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
c43c2cc5 4063
800eeca4
JW		 4064 _bfd_elf_print_private_bfd_data (abfd, ptr);
4065 return true;
4066}
4067\f
4068#define TARGET_LITTLE_SYM bfd_elf64_ia64_little_vec
4069#define TARGET_LITTLE_NAME "elf64-ia64-little"
4070#define TARGET_BIG_SYM bfd_elf64_ia64_big_vec
4071#define TARGET_BIG_NAME "elf64-ia64-big"
4072#define ELF_ARCH bfd_arch_ia64
4073#define ELF_MACHINE_CODE EM_IA_64
4074#define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4075#define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4076#define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4077
4078#define elf_backend_section_from_shdr \
4079 elf64_ia64_section_from_shdr
fa152c49
JW		 4080#define elf_backend_section_flags \
4081 elf64_ia64_section_flags
800eeca4
JW		 4082#define elf_backend_fake_sections \
4083 elf64_ia64_fake_sections
4084#define elf_backend_add_symbol_hook \
4085 elf64_ia64_add_symbol_hook
4086#define elf_backend_additional_program_headers \
4087 elf64_ia64_additional_program_headers
4088#define elf_backend_modify_segment_map \
4089 elf64_ia64_modify_segment_map
4090#define elf_info_to_howto \
4091 elf64_ia64_info_to_howto
4092
4093#define bfd_elf64_bfd_reloc_type_lookup \
4094 elf64_ia64_reloc_type_lookup
4095#define bfd_elf64_bfd_is_local_label_name \
4096 elf64_ia64_is_local_label_name
748abff6
RH		 4097#define bfd_elf64_bfd_relax_section \
4098 elf64_ia64_relax_section
800eeca4
JW		 4099
4100/* Stuff for the BFD linker: */
4101#define bfd_elf64_bfd_link_hash_table_create \
4102 elf64_ia64_hash_table_create
4103#define elf_backend_create_dynamic_sections \
4104 elf64_ia64_create_dynamic_sections
4105#define elf_backend_check_relocs \
4106 elf64_ia64_check_relocs
4107#define elf_backend_adjust_dynamic_symbol \
4108 elf64_ia64_adjust_dynamic_symbol
4109#define elf_backend_size_dynamic_sections \
4110 elf64_ia64_size_dynamic_sections
4111#define elf_backend_relocate_section \
4112 elf64_ia64_relocate_section
4113#define elf_backend_finish_dynamic_symbol \
4114 elf64_ia64_finish_dynamic_symbol
4115#define elf_backend_finish_dynamic_sections \
4116 elf64_ia64_finish_dynamic_sections
4117#define bfd_elf64_bfd_final_link \
4118 elf64_ia64_final_link
4119
4120#define bfd_elf64_bfd_copy_private_bfd_data \
4121 elf64_ia64_copy_private_bfd_data
4122#define bfd_elf64_bfd_merge_private_bfd_data \
4123 elf64_ia64_merge_private_bfd_data
4124#define bfd_elf64_bfd_set_private_flags \
4125 elf64_ia64_set_private_flags
4126#define bfd_elf64_bfd_print_private_bfd_data \
4127 elf64_ia64_print_private_bfd_data
4128
4129#define elf_backend_plt_readonly 1
4130#define elf_backend_want_plt_sym 0
4131#define elf_backend_plt_alignment 5
4132#define elf_backend_got_header_size 0
4133#define elf_backend_plt_header_size PLT_HEADER_SIZE
4134#define elf_backend_want_got_plt 1
4135#define elf_backend_may_use_rel_p 1
4136#define elf_backend_may_use_rela_p 1
4137#define elf_backend_default_use_rela_p 1
4138#define elf_backend_want_dynbss 0
4139#define elf_backend_copy_indirect_symbol elf64_ia64_hash_copy_indirect
4140#define elf_backend_hide_symbol elf64_ia64_hash_hide_symbol
4141
4142#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.188583 seconds and 4 git commands to generate.