?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* configure.tgt (i[3-7]86-*-solaris2*, i[3-7]86-*-solaris*): Correct
[binutils.git] / bfd / elf32-cris.c
blob4019e34e26b4b21a2e3080772b8cd9250c6ccf74
1 /* CRIS-specific support for 32-bit ELF.
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
4 Contributed by Axis Communications AB.
5 Written by Hans-Peter Nilsson, based on elf32-fr30.c
6 PIC and shlib bits based primarily on elf32-m68k.c and elf32-i386.c.
7
8 This file is part of BFD, the Binary File Descriptor library.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
23
24 #include "bfd.h"
25 #include "sysdep.h"
26 #include "libbfd.h"
27 #include "elf-bfd.h"
28 #include "elf/cris.h"
29
30 /* Forward declarations. */
31 static reloc_howto_type * cris_reloc_type_lookup
32 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
33
34 static void cris_info_to_howto_rela
35 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
36
37 static bfd_reloc_status_type cris_elf_pcrel_reloc
38 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
39
40 static bfd_boolean cris_elf_grok_prstatus
41 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
42
43 static bfd_boolean cris_elf_grok_psinfo
44 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
45
46 static bfd_boolean cris_elf_relocate_section
47 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
48 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
49
50 static bfd_reloc_status_type cris_final_link_relocate
51 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
52 Elf_Internal_Rela *, bfd_vma));
53
54 static bfd_boolean cris_elf_gc_sweep_hook
55 PARAMS ((bfd *, struct bfd_link_info *, asection *,
56 const Elf_Internal_Rela *));
57
58 static asection * cris_elf_gc_mark_hook
59 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
60 struct elf_link_hash_entry *, Elf_Internal_Sym *));
61
62 static bfd_boolean cris_elf_object_p PARAMS ((bfd *));
63
64 static void cris_elf_final_write_processing PARAMS ((bfd *, bfd_boolean));
65
66 static bfd_boolean cris_elf_set_mach_from_flags
67 PARAMS ((bfd *, unsigned long int));
68
69 static bfd_boolean cris_elf_print_private_bfd_data PARAMS ((bfd *, PTR));
70
71 static bfd_boolean cris_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
72 static bfd_boolean cris_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
73
74 struct elf_cris_link_hash_entry;
75 static bfd_boolean elf_cris_discard_excess_dso_dynamics
76 PARAMS ((struct elf_cris_link_hash_entry *, PTR));
77 static bfd_boolean elf_cris_discard_excess_program_dynamics
78 PARAMS ((struct elf_cris_link_hash_entry *, PTR));
79 static bfd_boolean elf_cris_adjust_gotplt_to_got
80 PARAMS ((struct elf_cris_link_hash_entry *, PTR));
81 static bfd_boolean elf_cris_try_fold_plt_to_got
82 PARAMS ((struct elf_cris_link_hash_entry *, PTR));
83 static struct bfd_hash_entry *elf_cris_link_hash_newfunc
84 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
85 static struct bfd_link_hash_table *elf_cris_link_hash_table_create
86 PARAMS ((bfd *));
87 static bfd_boolean elf_cris_adjust_dynamic_symbol
88 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
89 static bfd_boolean cris_elf_check_relocs
90 PARAMS ((bfd *, struct bfd_link_info *, asection *,
91 const Elf_Internal_Rela *));
92
93 static bfd_boolean elf_cris_size_dynamic_sections
94 PARAMS ((bfd *, struct bfd_link_info *));
95 static bfd_boolean elf_cris_finish_dynamic_symbol
96 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
97 Elf_Internal_Sym *));
98 static bfd_boolean elf_cris_finish_dynamic_sections
99 PARAMS ((bfd *, struct bfd_link_info *));
100 static void elf_cris_hide_symbol
101 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
102 static enum elf_reloc_type_class elf_cris_reloc_type_class
103 PARAMS ((const Elf_Internal_Rela *));
104
105 static reloc_howto_type cris_elf_howto_table [] =
106 {
107 /* This reloc does nothing. */
108 HOWTO (R_CRIS_NONE, /* type */
109 0, /* rightshift */
110 2, /* size (0 = byte, 1 = short, 2 = long) */
111 32, /* bitsize */
112 FALSE, /* pc_relative */
113 0, /* bitpos */
114 complain_overflow_bitfield, /* complain_on_overflow */
115 bfd_elf_generic_reloc, /* special_function */
116 "R_CRIS_NONE", /* name */
117 FALSE, /* partial_inplace */
118 0, /* src_mask */
119 0, /* dst_mask */
120 FALSE), /* pcrel_offset */
121
122 /* An 8 bit absolute relocation. */
123 HOWTO (R_CRIS_8, /* type */
124 0, /* rightshift */
125 0, /* size (0 = byte, 1 = short, 2 = long) */
126 8, /* bitsize */
127 FALSE, /* pc_relative */
128 0, /* bitpos */
129 complain_overflow_bitfield, /* complain_on_overflow */
130 bfd_elf_generic_reloc, /* special_function */
131 "R_CRIS_8", /* name */
132 FALSE, /* partial_inplace */
133 0x0000, /* src_mask */
134 0x00ff, /* dst_mask */
135 FALSE), /* pcrel_offset */
136
137 /* A 16 bit absolute relocation. */
138 HOWTO (R_CRIS_16, /* type */
139 0, /* rightshift */
140 1, /* size (0 = byte, 1 = short, 2 = long) */
141 16, /* bitsize */
142 FALSE, /* pc_relative */
143 0, /* bitpos */
144 complain_overflow_bitfield, /* complain_on_overflow */
145 bfd_elf_generic_reloc, /* special_function */
146 "R_CRIS_16", /* name */
147 FALSE, /* partial_inplace */
148 0x00000000, /* src_mask */
149 0x0000ffff, /* dst_mask */
150 FALSE), /* pcrel_offset */
151
152 /* A 32 bit absolute relocation. */
153 HOWTO (R_CRIS_32, /* type */
154 0, /* rightshift */
155 2, /* size (0 = byte, 1 = short, 2 = long) */
156 32, /* bitsize */
157 FALSE, /* pc_relative */
158 0, /* bitpos */
159 /* We don't want overflow complaints for 64-bit vma builds
160 for e.g. sym+0x40000000 (or actually sym-0xc0000000 in
161 32-bit ELF) where sym=0xc0001234.
162 Don't do this for the PIC relocs, as we don't expect to
163 see them with large offsets. */
164 complain_overflow_dont, /* complain_on_overflow */
165 bfd_elf_generic_reloc, /* special_function */
166 "R_CRIS_32", /* name */
167 FALSE, /* partial_inplace */
168 0x00000000, /* src_mask */
169 0xffffffff, /* dst_mask */
170 FALSE), /* pcrel_offset */
171
172 /* An 8 bit PC-relative relocation. */
173 HOWTO (R_CRIS_8_PCREL, /* type */
174 0, /* rightshift */
175 0, /* size (0 = byte, 1 = short, 2 = long) */
176 8, /* bitsize */
177 TRUE, /* pc_relative */
178 0, /* bitpos */
179 complain_overflow_bitfield, /* complain_on_overflow */
180 cris_elf_pcrel_reloc, /* special_function */
181 "R_CRIS_8_PCREL", /* name */
182 FALSE, /* partial_inplace */
183 0x0000, /* src_mask */
184 0x00ff, /* dst_mask */
185 TRUE), /* pcrel_offset */
186
187 /* A 16 bit PC-relative relocation. */
188 HOWTO (R_CRIS_16_PCREL, /* type */
189 0, /* rightshift */
190 1, /* size (0 = byte, 1 = short, 2 = long) */
191 16, /* bitsize */
192 TRUE, /* pc_relative */
193 0, /* bitpos */
194 complain_overflow_bitfield, /* complain_on_overflow */
195 cris_elf_pcrel_reloc, /* special_function */
196 "R_CRIS_16_PCREL", /* name */
197 FALSE, /* partial_inplace */
198 0x00000000, /* src_mask */
199 0x0000ffff, /* dst_mask */
200 TRUE), /* pcrel_offset */
201
202 /* A 32 bit PC-relative relocation. */
203 HOWTO (R_CRIS_32_PCREL, /* type */
204 0, /* rightshift */
205 2, /* size (0 = byte, 1 = short, 2 = long) */
206 32, /* bitsize */
207 TRUE, /* pc_relative */
208 0, /* bitpos */
209 complain_overflow_bitfield, /* complain_on_overflow */
210 cris_elf_pcrel_reloc, /* special_function */
211 "R_CRIS_32_PCREL", /* name */
212 FALSE, /* partial_inplace */
213 0x00000000, /* src_mask */
214 0xffffffff, /* dst_mask */
215 TRUE), /* pcrel_offset */
216
217 /* GNU extension to record C++ vtable hierarchy. */
218 HOWTO (R_CRIS_GNU_VTINHERIT, /* type */
219 0, /* rightshift */
220 2, /* size (0 = byte, 1 = short, 2 = long) */
221 0, /* bitsize */
222 FALSE, /* pc_relative */
223 0, /* bitpos */
224 complain_overflow_dont, /* complain_on_overflow */
225 NULL, /* special_function */
226 "R_CRIS_GNU_VTINHERIT", /* name */
227 FALSE, /* partial_inplace */
228 0, /* src_mask */
229 0, /* dst_mask */
230 FALSE), /* pcrel_offset */
231
232 /* GNU extension to record C++ vtable member usage. */
233 HOWTO (R_CRIS_GNU_VTENTRY, /* type */
234 0, /* rightshift */
235 2, /* size (0 = byte, 1 = short, 2 = long) */
236 0, /* bitsize */
237 FALSE, /* pc_relative */
238 0, /* bitpos */
239 complain_overflow_dont, /* complain_on_overflow */
240 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
241 "R_CRIS_GNU_VTENTRY", /* name */
242 FALSE, /* partial_inplace */
243 0, /* src_mask */
244 0, /* dst_mask */
245 FALSE), /* pcrel_offset */
246
247 /* This is used only by the dynamic linker. The symbol should exist
248 both in the object being run and in some shared library. The
249 dynamic linker copies the data addressed by the symbol from the
250 shared library into the object, because the object being
251 run has to have the data at some particular address. */
252 HOWTO (R_CRIS_COPY, /* type */
253 0, /* rightshift */
254 2, /* size (0 = byte, 1 = short, 2 = long) */
255 32, /* bitsize */
256 FALSE, /* pc_relative */
257 0, /* bitpos */
258 complain_overflow_bitfield, /* complain_on_overflow */
259 bfd_elf_generic_reloc, /* special_function */
260 "R_CRIS_COPY", /* name */
261 FALSE, /* partial_inplace */
262 0, /* src_mask */
263 0, /* dst_mask */
264 FALSE), /* pcrel_offset */
265
266 /* Like R_CRIS_32, but used when setting global offset table entries. */
267 HOWTO (R_CRIS_GLOB_DAT, /* type */
268 0, /* rightshift */
269 2, /* size (0 = byte, 1 = short, 2 = long) */
270 32, /* bitsize */
271 FALSE, /* pc_relative */
272 0, /* bitpos */
273 complain_overflow_bitfield, /* complain_on_overflow */
274 bfd_elf_generic_reloc, /* special_function */
275 "R_CRIS_GLOB_DAT", /* name */
276 FALSE, /* partial_inplace */
277 0, /* src_mask */
278 0xffffffff, /* dst_mask */
279 FALSE), /* pcrel_offset */
280
281 /* Marks a procedure linkage table entry for a symbol. */
282 HOWTO (R_CRIS_JUMP_SLOT, /* type */
283 0, /* rightshift */
284 2, /* size (0 = byte, 1 = short, 2 = long) */
285 32, /* bitsize */
286 FALSE, /* pc_relative */
287 0, /* bitpos */
288 complain_overflow_bitfield, /* complain_on_overflow */
289 bfd_elf_generic_reloc, /* special_function */
290 "R_CRIS_JUMP_SLOT", /* name */
291 FALSE, /* partial_inplace */
292 0, /* src_mask */
293 0, /* dst_mask */
294 FALSE), /* pcrel_offset */
295
296 /* Used only by the dynamic linker. When the object is run, this
297 longword is set to the load address of the object, plus the
298 addend. */
299 HOWTO (R_CRIS_RELATIVE, /* type */
300 0, /* rightshift */
301 2, /* size (0 = byte, 1 = short, 2 = long) */
302 32, /* bitsize */
303 FALSE, /* pc_relative */
304 0, /* bitpos */
305 complain_overflow_bitfield, /* complain_on_overflow */
306 bfd_elf_generic_reloc, /* special_function */
307 "R_CRIS_RELATIVE", /* name */
308 FALSE, /* partial_inplace */
309 0, /* src_mask */
310 0xffffffff, /* dst_mask */
311 FALSE), /* pcrel_offset */
312
313 /* Like R_CRIS_32, but referring to the GOT table entry for the symbol. */
314 HOWTO (R_CRIS_16_GOT, /* type */
315 0, /* rightshift */
316 1, /* size (0 = byte, 1 = short, 2 = long) */
317 16, /* bitsize */
318 FALSE, /* pc_relative */
319 0, /* bitpos */
320 complain_overflow_bitfield, /* complain_on_overflow */
321 bfd_elf_generic_reloc, /* special_function */
322 "R_CRIS_16_GOT", /* name */
323 FALSE, /* partial_inplace */
324 0, /* src_mask */
325 0xffff, /* dst_mask */
326 FALSE), /* pcrel_offset */
327
328 HOWTO (R_CRIS_32_GOT, /* type */
329 0, /* rightshift */
330 2, /* size (0 = byte, 1 = short, 2 = long) */
331 32, /* bitsize */
332 FALSE, /* pc_relative */
333 0, /* bitpos */
334 complain_overflow_bitfield, /* complain_on_overflow */
335 bfd_elf_generic_reloc, /* special_function */
336 "R_CRIS_32_GOT", /* name */
337 FALSE, /* partial_inplace */
338 0, /* src_mask */
339 0xffffffff, /* dst_mask */
340 FALSE), /* pcrel_offset */
341
342 /* Like R_CRIS_32_GOT, but referring to (and requesting a) PLT part of
343 the GOT table for the symbol. */
344 HOWTO (R_CRIS_16_GOTPLT, /* type */
345 0, /* rightshift */
346 1, /* size (0 = byte, 1 = short, 2 = long) */
347 16, /* bitsize */
348 FALSE, /* pc_relative */
349 0, /* bitpos */
350 complain_overflow_bitfield, /* complain_on_overflow */
351 bfd_elf_generic_reloc, /* special_function */
352 "R_CRIS_16_GOTPLT", /* name */
353 FALSE, /* partial_inplace */
354 0, /* src_mask */
355 0xffff, /* dst_mask */
356 FALSE), /* pcrel_offset */
357
358 HOWTO (R_CRIS_32_GOTPLT, /* type */
359 0, /* rightshift */
360 2, /* size (0 = byte, 1 = short, 2 = long) */
361 32, /* bitsize */
362 FALSE, /* pc_relative */
363 0, /* bitpos */
364 complain_overflow_bitfield, /* complain_on_overflow */
365 bfd_elf_generic_reloc, /* special_function */
366 "R_CRIS_32_GOTPLT", /* name */
367 FALSE, /* partial_inplace */
368 0, /* src_mask */
369 0xffffffff, /* dst_mask */
370 FALSE), /* pcrel_offset */
371
372 /* A 32-bit offset from GOT to (local const) symbol: no GOT entry should
373 be necessary. */
374 HOWTO (R_CRIS_32_GOTREL, /* type */
375 0, /* rightshift */
376 2, /* size (0 = byte, 1 = short, 2 = long) */
377 32, /* bitsize */
378 FALSE, /* pc_relative */
379 0, /* bitpos */
380 complain_overflow_bitfield, /* complain_on_overflow */
381 bfd_elf_generic_reloc, /* special_function */
382 "R_CRIS_32_GOTREL", /* name */
383 FALSE, /* partial_inplace */
384 0, /* src_mask */
385 0xffffffff, /* dst_mask */
386 FALSE), /* pcrel_offset */
387
388 /* A 32-bit offset from GOT to entry for this symbol in PLT and request
389 to create PLT entry for symbol. */
390 HOWTO (R_CRIS_32_PLT_GOTREL, /* type */
391 0, /* rightshift */
392 2, /* size (0 = byte, 1 = short, 2 = long) */
393 32, /* bitsize */
394 FALSE, /* pc_relative */
395 0, /* bitpos */
396 complain_overflow_bitfield, /* complain_on_overflow */
397 bfd_elf_generic_reloc, /* special_function */
398 "R_CRIS_32_PLT_GOTREL", /* name */
399 FALSE, /* partial_inplace */
400 0, /* src_mask */
401 0xffffffff, /* dst_mask */
402 FALSE), /* pcrel_offset */
403
404 /* A 32-bit offset from PC (location after the relocation) + addend to
405 entry for this symbol in PLT and request to create PLT entry for
406 symbol. */
407 HOWTO (R_CRIS_32_PLT_PCREL, /* type */
408 0, /* rightshift */
409 2, /* size (0 = byte, 1 = short, 2 = long) */
410 32, /* bitsize */
411 TRUE, /* pc_relative */
412 0, /* bitpos */
413 complain_overflow_bitfield, /* complain_on_overflow */
414 cris_elf_pcrel_reloc, /* special_function */
415 "R_CRIS_32_PLT_PCREL", /* name */
416 FALSE, /* partial_inplace */
417 0, /* src_mask */
418 0xffffffff, /* dst_mask */
419 TRUE) /* pcrel_offset */
420 };
421 \f
422 /* Map BFD reloc types to CRIS ELF reloc types. */
423
424 struct cris_reloc_map
425 {
426 bfd_reloc_code_real_type bfd_reloc_val;
427 unsigned int cris_reloc_val;
428 };
429
430 static const struct cris_reloc_map cris_reloc_map [] =
431 {
432 { BFD_RELOC_NONE, R_CRIS_NONE },
433 { BFD_RELOC_8, R_CRIS_8 },
434 { BFD_RELOC_16, R_CRIS_16 },
435 { BFD_RELOC_32, R_CRIS_32 },
436 { BFD_RELOC_8_PCREL, R_CRIS_8_PCREL },
437 { BFD_RELOC_16_PCREL, R_CRIS_16_PCREL },
438 { BFD_RELOC_32_PCREL, R_CRIS_32_PCREL },
439 { BFD_RELOC_VTABLE_INHERIT, R_CRIS_GNU_VTINHERIT },
440 { BFD_RELOC_VTABLE_ENTRY, R_CRIS_GNU_VTENTRY },
441 { BFD_RELOC_CRIS_COPY, R_CRIS_COPY },
442 { BFD_RELOC_CRIS_GLOB_DAT, R_CRIS_GLOB_DAT },
443 { BFD_RELOC_CRIS_JUMP_SLOT, R_CRIS_JUMP_SLOT },
444 { BFD_RELOC_CRIS_RELATIVE, R_CRIS_RELATIVE },
445 { BFD_RELOC_CRIS_16_GOT, R_CRIS_16_GOT },
446 { BFD_RELOC_CRIS_32_GOT, R_CRIS_32_GOT },
447 { BFD_RELOC_CRIS_16_GOTPLT, R_CRIS_16_GOTPLT },
448 { BFD_RELOC_CRIS_32_GOTPLT, R_CRIS_32_GOTPLT },
449 { BFD_RELOC_CRIS_32_GOTREL, R_CRIS_32_GOTREL },
450 { BFD_RELOC_CRIS_32_PLT_GOTREL, R_CRIS_32_PLT_GOTREL },
451 { BFD_RELOC_CRIS_32_PLT_PCREL, R_CRIS_32_PLT_PCREL }
452 };
453
454 static reloc_howto_type *
455 cris_reloc_type_lookup (abfd, code)
456 bfd * abfd ATTRIBUTE_UNUSED;
457 bfd_reloc_code_real_type code;
458 {
459 unsigned int i;
460
461 for (i = 0; i < sizeof (cris_reloc_map) / sizeof (cris_reloc_map[0]); i++)
462 if (cris_reloc_map [i].bfd_reloc_val == code)
463 return & cris_elf_howto_table [cris_reloc_map[i].cris_reloc_val];
464
465 return NULL;
466 }
467
468 /* Set the howto pointer for an CRIS ELF reloc. */
469
470 static void
471 cris_info_to_howto_rela (abfd, cache_ptr, dst)
472 bfd * abfd ATTRIBUTE_UNUSED;
473 arelent * cache_ptr;
474 Elf_Internal_Rela * dst;
475 {
476 unsigned int r_type;
477
478 r_type = ELF32_R_TYPE (dst->r_info);
479 BFD_ASSERT (r_type < (unsigned int) R_CRIS_max);
480 cache_ptr->howto = & cris_elf_howto_table [r_type];
481 }
482
483 bfd_reloc_status_type
484 cris_elf_pcrel_reloc (abfd, reloc_entry, symbol, data, input_section,
485 output_bfd, error_message)
486 bfd *abfd ATTRIBUTE_UNUSED;
487 arelent *reloc_entry;
488 asymbol *symbol;
489 PTR data ATTRIBUTE_UNUSED;
490 asection *input_section;
491 bfd *output_bfd;
492 char **error_message ATTRIBUTE_UNUSED;
493 {
494 /* By default (using only bfd_elf_generic_reloc when linking to
495 non-ELF formats) PC-relative relocs are relative to the beginning
496 of the reloc. CRIS PC-relative relocs are relative to the position
497 *after* the reloc because that's what pre-CRISv32 PC points to
498 after reading an insn field with that reloc. (For CRISv32, PC is
499 actually relative to the start of the insn, but we keep the old
500 definition.) Still, we use as much generic machinery as we can.
501
502 Only adjust when doing a final link. */
503 if (output_bfd == (bfd *) NULL)
504 reloc_entry->addend -= 1 << reloc_entry->howto->size;
505
506 return
507 bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
508 input_section, output_bfd, error_message);
509 }
510 \f
511 /* Support for core dump NOTE sections.
512 The slightly unintuitive code layout is an attempt to keep at least
513 some similarities with other ports, hoping to simplify general
514 changes, while still keeping Linux/CRIS and Linux/CRISv32 code apart. */
515
516 static bfd_boolean
517 cris_elf_grok_prstatus (abfd, note)
518 bfd *abfd;
519 Elf_Internal_Note *note;
520 {
521 int offset;
522 size_t size;
523
524 if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
525 switch (note->descsz)
526 {
527 default:
528 return FALSE;
529
530 case 202: /* Linux/CRISv32 */
531 /* pr_cursig */
532 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
533
534 /* pr_pid */
535 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 22);
536
537 /* pr_reg */
538 offset = 70;
539 size = 128;
540
541 break;
542 }
543 else
544 switch (note->descsz)
545 {
546 default:
547 return FALSE;
548
549 case 214: /* Linux/CRIS */
550 /* pr_cursig */
551 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
552
553 /* pr_pid */
554 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 22);
555
556 /* pr_reg */
557 offset = 70;
558 size = 140;
559
560 break;
561 }
562
563 /* Make a ".reg/999" section. */
564 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
565 size, note->descpos + offset);
566 }
567
568 static bfd_boolean
569 cris_elf_grok_psinfo (abfd, note)
570 bfd *abfd;
571 Elf_Internal_Note *note;
572 {
573 if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
574 switch (note->descsz)
575 {
576 default:
577 return FALSE;
578
579 case 124: /* Linux/CRISv32 elf_prpsinfo */
580 elf_tdata (abfd)->core_program
581 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
582 elf_tdata (abfd)->core_command
583 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
584 }
585 else
586 switch (note->descsz)
587 {
588 default:
589 return FALSE;
590
591 case 124: /* Linux/CRIS elf_prpsinfo */
592 elf_tdata (abfd)->core_program
593 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
594 elf_tdata (abfd)->core_command
595 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
596 }
597
598 /* Note that for some reason, a spurious space is tacked
599 onto the end of the args in some (at least one anyway)
600 implementations, so strip it off if it exists. */
601
602 {
603 char *command = elf_tdata (abfd)->core_command;
604 int n = strlen (command);
605
606 if (0 < n && command[n - 1] == ' ')
607 command[n - 1] = '\0';
608 }
609
610 return TRUE;
611 }
612 \f
613 /* The name of the dynamic interpreter. This is put in the .interp
614 section. */
615
616 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
617
618 /* The size in bytes of an entry in the procedure linkage table. */
619
620 #define PLT_ENTRY_SIZE 20
621 #define PLT_ENTRY_SIZE_V32 26
622
623 /* The first entry in an absolute procedure linkage table looks like this. */
624
625 static const bfd_byte elf_cris_plt0_entry[PLT_ENTRY_SIZE] =
626 {
627 0xfc, 0xe1,
628 0x7e, 0x7e, /* push mof. */
629 0x7f, 0x0d, /* (dip [pc+]) */
630 0, 0, 0, 0, /* Replaced with address of .got + 4. */
631 0x30, 0x7a, /* move [...],mof */
632 0x7f, 0x0d, /* (dip [pc+]) */
633 0, 0, 0, 0, /* Replaced with address of .got + 8. */
634 0x30, 0x09 /* jump [...] */
635 };
636
637 static const bfd_byte elf_cris_plt0_entry_v32[PLT_ENTRY_SIZE_V32] =
638 {
639 0x84, 0xe2, /* subq 4,$sp */
640 0x6f, 0xfe, /* move.d 0,$acr */
641 0, 0, 0, 0, /* Replaced by address of .got + 4. */
642 0x7e, 0x7a, /* move $mof,[$sp] */
643 0x3f, 0x7a, /* move [$acr],$mof */
644 0x04, 0xf2, /* addq 4,acr */
645 0x6f, 0xfa, /* move.d [$acr],$acr */
646 0xbf, 0x09, /* jump $acr */
647 0xb0, 0x05, /* nop */
648 0, 0 /* Pad out to 26 bytes. */
649 };
650
651 /* Subsequent entries in an absolute procedure linkage table look like
652 this. */
653
654 static const bfd_byte elf_cris_plt_entry[PLT_ENTRY_SIZE] =
655 {
656 0x7f, 0x0d, /* (dip [pc+]) */
657 0, 0, 0, 0, /* Replaced with address of this symbol in .got. */
658 0x30, 0x09, /* jump [...] */
659 0x3f, 0x7e, /* move [pc+],mof */
660 0, 0, 0, 0, /* Replaced with offset into relocation table. */
661 0x2f, 0xfe, /* add.d [pc+],pc */
662 0xec, 0xff,
663 0xff, 0xff /* Replaced with offset to start of .plt. */
664 };
665
666 static const bfd_byte elf_cris_plt_entry_v32[PLT_ENTRY_SIZE_V32] =
667 {
668 0x6f, 0xfe, /* move.d 0,$acr */
669 0, 0, 0, 0, /* Replaced with address of this symbol in .got. */
670 0x6f, 0xfa, /* move.d [$acr],$acr */
671 0xbf, 0x09, /* jump $acr */
672 0xb0, 0x05, /* nop */
673 0x3f, 0x7e, /* move 0,mof */
674 0, 0, 0, 0, /* Replaced with offset into relocation table. */
675 0xbf, 0x0e, /* ba start_of_plt0_entry */
676 0, 0, 0, 0, /* Replaced with offset to plt0 entry. */
677 0xb0, 0x05 /* nop */
678 };
679
680 /* The first entry in a PIC procedure linkage table looks like this. */
681
682 static const bfd_byte elf_cris_pic_plt0_entry[PLT_ENTRY_SIZE] =
683 {
684 0xfc, 0xe1, 0x7e, 0x7e, /* push mof */
685 0x04, 0x01, 0x30, 0x7a, /* move [r0+4],mof */
686 0x08, 0x01, 0x30, 0x09, /* jump [r0+8] */
687 0, 0, 0, 0, 0, 0, 0, 0, /* Pad out to 20 bytes. */
688 };
689
690 static const bfd_byte elf_cris_pic_plt0_entry_v32[PLT_ENTRY_SIZE_V32] =
691 {
692 0x84, 0xe2, /* subq 4,$sp */
693 0x04, 0x01, /* addoq 4,$r0,$acr */
694 0x7e, 0x7a, /* move $mof,[$sp] */
695 0x3f, 0x7a, /* move [$acr],$mof */
696 0x04, 0xf2, /* addq 4,$acr */
697 0x6f, 0xfa, /* move.d [$acr],$acr */
698 0xbf, 0x09, /* jump $acr */
699 0xb0, 0x05, /* nop */
700 0, 0, /* Pad out to 26 bytes. */
701 0, 0, 0, 0,
702 0, 0, 0, 0
703 };
704
705 /* Subsequent entries in a PIC procedure linkage table look like this. */
706
707 static const bfd_byte elf_cris_pic_plt_entry[PLT_ENTRY_SIZE] =
708 {
709 0x6f, 0x0d, /* (bdap [pc+].d,r0) */
710 0, 0, 0, 0, /* Replaced with offset of this symbol in .got. */
711 0x30, 0x09, /* jump [...] */
712 0x3f, 0x7e, /* move [pc+],mof */
713 0, 0, 0, 0, /* Replaced with offset into relocation table. */
714 0x2f, 0xfe, /* add.d [pc+],pc */
715 0xec, 0xff, /* Replaced with offset to start of .plt. */
716 0xff, 0xff
717 };
718
719 static const bfd_byte elf_cris_pic_plt_entry_v32[PLT_ENTRY_SIZE_V32] =
720 {
721 0x6f, 0x0d, /* addo.d 0,$r0,$acr */
722 0, 0, 0, 0, /* Replaced with offset of this symbol in .got. */
723 0x6f, 0xfa, /* move.d [$acr],$acr */
724 0xbf, 0x09, /* jump $acr */
725 0xb0, 0x05, /* nop */
726 0x3f, 0x7e, /* move relocoffs,$mof */
727 0, 0, 0, 0, /* Replaced with offset into relocation table. */
728 0xbf, 0x0e, /* ba start_of_plt */
729 0, 0, 0, 0, /* Replaced with offset to start of .plt. */
730 0xb0, 0x05 /* nop */
731 };
732 \f
733 /* We copy elf32-m68k.c and elf32-i386.c for the basic linker hash bits
734 (and most other PIC/shlib stuff). Check that we don't drift away
735 without reason.
736
737 The CRIS linker, like the m68k and i386 linkers (and probably the rest
738 too) needs to keep track of the number of relocs that it decides to
739 copy in check_relocs for each symbol. This is so that it can discard
740 PC relative relocs if it doesn't need them when linking with
741 -Bsymbolic. We store the information in a field extending the regular
742 ELF linker hash table. */
743
744 /* This structure keeps track of the number of PC relative relocs we have
745 copied for a given symbol. */
746
747 struct elf_cris_pcrel_relocs_copied
748 {
749 /* Next section. */
750 struct elf_cris_pcrel_relocs_copied *next;
751 /* A section in dynobj. */
752 asection *section;
753 /* Number of relocs copied in this section. */
754 bfd_size_type count;
755 };
756
757 /* CRIS ELF linker hash entry. */
758
759 struct elf_cris_link_hash_entry
760 {
761 struct elf_link_hash_entry root;
762
763 /* Number of PC relative relocs copied for this symbol. */
764 struct elf_cris_pcrel_relocs_copied *pcrel_relocs_copied;
765
766 /* The GOTPLT references are CRIS-specific; the goal is to avoid having
767 both a general GOT and a PLT-specific GOT entry for the same symbol,
768 when it is referenced both as a function and as a function pointer.
769
770 Number of GOTPLT references for a function. */
771 bfd_signed_vma gotplt_refcount;
772
773 /* Actual GOTPLT index for this symbol, if applicable, or zero if not
774 (zero is never used as an index). FIXME: We should be able to fold
775 this with gotplt_refcount in a union, like the got and plt unions in
776 elf_link_hash_entry. */
777 bfd_size_type gotplt_offset;
778 };
779
780 /* CRIS ELF linker hash table. */
781
782 struct elf_cris_link_hash_table
783 {
784 struct elf_link_hash_table root;
785
786 /* We can't use the PLT offset and calculate to get the GOTPLT offset,
787 since we try and avoid creating GOTPLT:s when there's already a GOT.
788 Instead, we keep and update the next available index here. */
789 bfd_size_type next_gotplt_entry;
790 };
791
792 /* Traverse a CRIS ELF linker hash table. */
793
794 #define elf_cris_link_hash_traverse(table, func, info) \
795 (elf_link_hash_traverse \
796 (&(table)->root, \
797 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
798 (info)))
799
800 /* Get the CRIS ELF linker hash table from a link_info structure. */
801
802 #define elf_cris_hash_table(p) \
803 ((struct elf_cris_link_hash_table *) (p)->hash)
804
805 /* Create an entry in a CRIS ELF linker hash table. */
806
807 static struct bfd_hash_entry *
808 elf_cris_link_hash_newfunc (entry, table, string)
809 struct bfd_hash_entry *entry;
810 struct bfd_hash_table *table;
811 const char *string;
812 {
813 struct elf_cris_link_hash_entry *ret =
814 (struct elf_cris_link_hash_entry *) entry;
815
816 /* Allocate the structure if it has not already been allocated by a
817 subclass. */
818 if (ret == (struct elf_cris_link_hash_entry *) NULL)
819 ret = ((struct elf_cris_link_hash_entry *)
820 bfd_hash_allocate (table,
821 sizeof (struct elf_cris_link_hash_entry)));
822 if (ret == (struct elf_cris_link_hash_entry *) NULL)
823 return (struct bfd_hash_entry *) ret;
824
825 /* Call the allocation method of the superclass. */
826 ret = ((struct elf_cris_link_hash_entry *)
827 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
828 table, string));
829 if (ret != (struct elf_cris_link_hash_entry *) NULL)
830 {
831 ret->pcrel_relocs_copied = NULL;
832 ret->gotplt_refcount = 0;
833 ret->gotplt_offset = 0;
834 }
835
836 return (struct bfd_hash_entry *) ret;
837 }
838
839 /* Create a CRIS ELF linker hash table. */
840
841 static struct bfd_link_hash_table *
842 elf_cris_link_hash_table_create (abfd)
843 bfd *abfd;
844 {
845 struct elf_cris_link_hash_table *ret;
846 bfd_size_type amt = sizeof (struct elf_cris_link_hash_table);
847
848 ret = ((struct elf_cris_link_hash_table *) bfd_malloc (amt));
849 if (ret == (struct elf_cris_link_hash_table *) NULL)
850 return NULL;
851
852 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
853 elf_cris_link_hash_newfunc,
854 sizeof (struct elf_cris_link_hash_entry)))
855 {
856 free (ret);
857 return NULL;
858 }
859
860 /* Initialize to skip over the first three entries in the gotplt; they
861 are used for run-time symbol evaluation. */
862 ret->next_gotplt_entry = 12;
863
864 return &ret->root.root;
865 }
866 \f
867 /* Perform a single relocation. By default we use the standard BFD
868 routines, with a few tweaks. */
869
870 static bfd_reloc_status_type
871 cris_final_link_relocate (howto, input_bfd, input_section, contents, rel,
872 relocation)
873 reloc_howto_type * howto;
874 bfd * input_bfd;
875 asection * input_section;
876 bfd_byte * contents;
877 Elf_Internal_Rela * rel;
878 bfd_vma relocation;
879 {
880 bfd_reloc_status_type r;
881
882 /* PC-relative relocations are relative to the position *after*
883 the reloc. Note that for R_CRIS_8_PCREL the adjustment is
884 not a single byte, since PC must be 16-bit-aligned. */
885 switch (ELF32_R_TYPE (rel->r_info))
886 {
887 /* Check that the 16-bit GOT relocs are positive. */
888 case R_CRIS_16_GOTPLT:
889 case R_CRIS_16_GOT:
890 if ((bfd_signed_vma) relocation < 0)
891 return bfd_reloc_overflow;
892 break;
893
894 case R_CRIS_32_PLT_PCREL:
895 case R_CRIS_32_PCREL:
896 relocation -= 2;
897 /* Fall through. */
898 case R_CRIS_8_PCREL:
899 case R_CRIS_16_PCREL:
900 relocation -= 2;
901 break;
902
903 default:
904 break;
905 }
906
907 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
908 contents, rel->r_offset,
909 relocation, rel->r_addend);
910 return r;
911 }
912 \f
913 /* Relocate an CRIS ELF section. See elf32-fr30.c, from where this was
914 copied, for further comments. */
915
916 static bfd_boolean
917 cris_elf_relocate_section (output_bfd, info, input_bfd, input_section,
918 contents, relocs, local_syms, local_sections)
919 bfd *output_bfd ATTRIBUTE_UNUSED;
920 struct bfd_link_info *info;
921 bfd *input_bfd;
922 asection *input_section;
923 bfd_byte *contents;
924 Elf_Internal_Rela *relocs;
925 Elf_Internal_Sym *local_syms;
926 asection **local_sections;
927 {
928 bfd *dynobj;
929 Elf_Internal_Shdr *symtab_hdr;
930 struct elf_link_hash_entry **sym_hashes;
931 bfd_vma *local_got_offsets;
932 asection *sgot;
933 asection *splt;
934 asection *sreloc;
935 Elf_Internal_Rela *rel;
936 Elf_Internal_Rela *relend;
937
938 if (info->relocatable)
939 return TRUE;
940
941 dynobj = elf_hash_table (info)->dynobj;
942 local_got_offsets = elf_local_got_offsets (input_bfd);
943 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
944 sym_hashes = elf_sym_hashes (input_bfd);
945 relend = relocs + input_section->reloc_count;
946
947 sgot = NULL;
948 splt = NULL;
949 sreloc = NULL;
950
951 if (dynobj != NULL)
952 {
953 splt = bfd_get_section_by_name (dynobj, ".plt");
954 sgot = bfd_get_section_by_name (dynobj, ".got");
955 }
956
957 for (rel = relocs; rel < relend; rel ++)
958 {
959 reloc_howto_type *howto;
960 unsigned long r_symndx;
961 Elf_Internal_Sym *sym;
962 asection *sec;
963 struct elf_link_hash_entry *h;
964 bfd_vma relocation;
965 bfd_reloc_status_type r;
966 const char *symname = NULL;
967 int r_type;
968
969 r_type = ELF32_R_TYPE (rel->r_info);
970
971 if ( r_type == R_CRIS_GNU_VTINHERIT
972 || r_type == R_CRIS_GNU_VTENTRY)
973 continue;
974
975 /* This is a final link. */
976 r_symndx = ELF32_R_SYM (rel->r_info);
977 howto = cris_elf_howto_table + r_type;
978 h = NULL;
979 sym = NULL;
980 sec = NULL;
981
982 if (r_symndx < symtab_hdr->sh_info)
983 {
984 sym = local_syms + r_symndx;
985 sec = local_sections [r_symndx];
986 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
987
988 symname = (bfd_elf_string_from_elf_section
989 (input_bfd, symtab_hdr->sh_link, sym->st_name));
990 if (symname == NULL)
991 symname = bfd_section_name (input_bfd, sec);
992 }
993 else
994 {
995 bfd_boolean warned;
996 bfd_boolean unresolved_reloc;
997
998 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
999 r_symndx, symtab_hdr, sym_hashes,
1000 h, sec, relocation,
1001 unresolved_reloc, warned);
1002
1003 if (unresolved_reloc
1004 /* Perhaps we should detect the cases that
1005 sec->output_section is expected to be NULL like i386 and
1006 m68k, but apparently (and according to elfxx-ia64.c) all
1007 valid cases are where the symbol is defined in a shared
1008 object which we link dynamically against. This includes
1009 PLT relocs for which we've created a PLT entry and other
1010 relocs for which we're prepared to create dynamic
1011 relocations.
1012
1013 For now, new situations cause us to just err when
1014 sec->output_offset is NULL but the object with the symbol
1015 is *not* dynamically linked against. Thus this will
1016 automatically remind us so we can see if there are other
1017 valid cases we need to revisit. */
1018 && (sec->owner->flags & DYNAMIC) != 0)
1019 relocation = 0;
1020
1021 else if (h->root.type == bfd_link_hash_defined
1022 || h->root.type == bfd_link_hash_defweak)
1023 {
1024 /* Here follow the cases where the relocation value must
1025 be zero (or when further handling is simplified when
1026 zero). I can't claim to understand the various
1027 conditions and they weren't described in the files
1028 where I copied them from (elf32-m68k.c and
1029 elf32-i386.c), but let's mention examples of where
1030 they happen. FIXME: Perhaps define and use a
1031 dynamic_symbol_p function like ia64.
1032
1033 - When creating a shared library, we can have an
1034 ordinary relocation for a symbol defined in a shared
1035 library (perhaps the one we create). We then make
1036 the relocation value zero, as the value seen now will
1037 be added into the relocation addend in this shared
1038 library, but must be handled only at dynamic-link
1039 time. FIXME: Not sure this example covers the
1040 h->elf_link_hash_flags test, though it's there in
1041 other targets. */
1042 if (info->shared
1043 && ((! info->symbolic && h->dynindx != -1)
1044 || !h->def_regular)
1045 && (input_section->flags & SEC_ALLOC) != 0
1046 && (r_type == R_CRIS_8
1047 || r_type == R_CRIS_16
1048 || r_type == R_CRIS_32
1049 || r_type == R_CRIS_8_PCREL
1050 || r_type == R_CRIS_16_PCREL
1051 || r_type == R_CRIS_32_PCREL))
1052 relocation = 0;
1053 else if (unresolved_reloc)
1054 {
1055 _bfd_error_handler
1056 (_("%B, section %A: unresolvable relocation %s against symbol `%s'"),
1057 input_bfd,
1058 input_section,
1059 cris_elf_howto_table[r_type].name,
1060 symname);
1061 bfd_set_error (bfd_error_bad_value);
1062 return FALSE;
1063 }
1064 }
1065 }
1066
1067 switch (r_type)
1068 {
1069 case R_CRIS_16_GOTPLT:
1070 case R_CRIS_32_GOTPLT:
1071 /* This is like the case for R_CRIS_32_GOT and R_CRIS_16_GOT,
1072 but we require a PLT, and the PLT handling will take care of
1073 filling in the PLT-specific GOT entry. For the GOT offset,
1074 calculate it as we do when filling it in for the .got.plt
1075 section. If we don't have a PLT, punt to GOT handling. */
1076 if (h != NULL
1077 && ((struct elf_cris_link_hash_entry *) h)->gotplt_offset != 0)
1078 {
1079 asection *sgotplt
1080 = bfd_get_section_by_name (dynobj, ".got.plt");
1081 bfd_vma got_offset;
1082
1083 BFD_ASSERT (h->dynindx != -1);
1084 BFD_ASSERT (sgotplt != NULL);
1085
1086 got_offset
1087 = ((struct elf_cris_link_hash_entry *) h)->gotplt_offset;
1088
1089 relocation = got_offset;
1090 break;
1091 }
1092
1093 /* We didn't make a PLT entry for this symbol. Maybe everything is
1094 folded into the GOT. Other than folding, this happens when
1095 statically linking PIC code, or when using -Bsymbolic. Check
1096 that we instead have a GOT entry as done for us by
1097 elf_cris_adjust_dynamic_symbol, and drop through into the
1098 ordinary GOT cases. This must not happen for the
1099 executable, because any reference it does to a function
1100 that is satisfied by a DSO must generate a PLT. We assume
1101 these call-specific relocs don't address non-functions. */
1102 if (h != NULL
1103 && (h->got.offset == (bfd_vma) -1
1104 || (!info->shared
1105 && !(h->def_regular
1106 || (!h->def_dynamic
1107 && h->root.type == bfd_link_hash_undefweak)))))
1108 {
1109 (*_bfd_error_handler)
1110 ((h->got.offset == (bfd_vma) -1)
1111 ? _("%B, section %A: No PLT nor GOT for relocation %s"
1112 " against symbol `%s'")
1113 : _("%B, section %A: No PLT for relocation %s"
1114 " against symbol `%s'"),
1115 input_bfd,
1116 input_section,
1117 cris_elf_howto_table[r_type].name,
1118 (symname != NULL && symname[0] != '\0'
1119 ? symname : _("[whose name is lost]")));
1120
1121 /* FIXME: Perhaps blaming input is not the right thing to
1122 do; this is probably an internal error. But it is true
1123 that we didn't like that particular input. */
1124 bfd_set_error (bfd_error_bad_value);
1125 return FALSE;
1126 }
1127 /* Fall through. */
1128
1129 /* The size of the actual relocation is not used here; we only
1130 fill in the GOT table here. */
1131 case R_CRIS_16_GOT:
1132 case R_CRIS_32_GOT:
1133 {
1134 bfd_vma off;
1135
1136 /* Note that despite using RELA relocations, the .got contents
1137 is always filled in with the link-relative relocation
1138 value; the addend. */
1139
1140 if (h != NULL)
1141 {
1142 off = h->got.offset;
1143 BFD_ASSERT (off != (bfd_vma) -1);
1144
1145 if (!elf_hash_table (info)->dynamic_sections_created
1146 || (! info->shared
1147 && (h->def_regular
1148 || h->type == STT_FUNC
1149 || h->needs_plt))
1150 || (info->shared
1151 && (info->symbolic || h->dynindx == -1)
1152 && h->def_regular))
1153 {
1154 /* This wasn't checked above for ! info->shared, but
1155 must hold there if we get here; the symbol must
1156 be defined in the regular program or be undefweak
1157 or be a function or otherwise need a PLT. */
1158 BFD_ASSERT (!elf_hash_table (info)->dynamic_sections_created
1159 || info->shared
1160 || h->def_regular
1161 || h->type == STT_FUNC
1162 || h->needs_plt
1163 || h->root.type == bfd_link_hash_undefweak);
1164
1165 /* This is actually a static link, or it is a
1166 -Bsymbolic link and the symbol is defined locally,
1167 or is undefweak, or the symbol was forced to be
1168 local because of a version file, or we're not
1169 creating a dynamic object. We must initialize this
1170 entry in the global offset table. Since the offset
1171 must always be a multiple of 4, we use the least
1172 significant bit to record whether we have
1173 initialized it already.
1174
1175 If this GOT entry should be runtime-initialized, we
1176 will create a .rela.got relocation entry to
1177 initialize the value. This is done in the
1178 finish_dynamic_symbol routine. */
1179 if ((off & 1) != 0)
1180 off &= ~1;
1181 else
1182 {
1183 bfd_put_32 (output_bfd, relocation,
1184 sgot->contents + off);
1185 h->got.offset |= 1;
1186 }
1187 }
1188 }
1189 else
1190 {
1191 BFD_ASSERT (local_got_offsets != NULL
1192 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1193
1194 off = local_got_offsets[r_symndx];
1195
1196 /* The offset must always be a multiple of 4. We use
1197 the least significant bit to record whether we have
1198 already generated the necessary reloc. */
1199 if ((off & 1) != 0)
1200 off &= ~1;
1201 else
1202 {
1203 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1204
1205 if (info->shared)
1206 {
1207 asection *s;
1208 Elf_Internal_Rela outrel;
1209 bfd_byte *loc;
1210
1211 s = bfd_get_section_by_name (dynobj, ".rela.got");
1212 BFD_ASSERT (s != NULL);
1213
1214 outrel.r_offset = (sgot->output_section->vma
1215 + sgot->output_offset
1216 + off);
1217 outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1218 outrel.r_addend = relocation;
1219 loc = s->contents;
1220 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1221 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1222 }
1223
1224 local_got_offsets[r_symndx] |= 1;
1225 }
1226 }
1227
1228 relocation = sgot->output_offset + off;
1229 if (rel->r_addend != 0)
1230 {
1231 /* We can't do anything for a relocation which is against
1232 a symbol *plus offset*. GOT holds relocations for
1233 symbols. Make this an error; the compiler isn't
1234 allowed to pass us these kinds of things. */
1235 if (h == NULL)
1236 (*_bfd_error_handler)
1237 (_("%B, section %A: relocation %s with non-zero addend %d"
1238 " against local symbol"),
1239 input_bfd,
1240 input_section,
1241 cris_elf_howto_table[r_type].name,
1242 rel->r_addend);
1243 else
1244 (*_bfd_error_handler)
1245 (_("%B, section %A: relocation %s with non-zero addend %d"
1246 " against symbol `%s'"),
1247 input_bfd,
1248 input_section,
1249 cris_elf_howto_table[r_type].name,
1250 rel->r_addend,
1251 symname[0] != '\0' ? symname : _("[whose name is lost]"));
1252
1253 bfd_set_error (bfd_error_bad_value);
1254 return FALSE;
1255 }
1256 }
1257 break;
1258
1259 case R_CRIS_32_GOTREL:
1260 /* This relocation must only be performed against local symbols.
1261 It's also ok when we link a program and the symbol is either
1262 defined in an ordinary (non-DSO) object or is undefined weak. */
1263 if (h != NULL
1264 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1265 && !(!info->shared
1266 && (h->def_regular
1267 || (!h->def_dynamic
1268 && h->root.type == bfd_link_hash_undefweak))))
1269 {
1270 (*_bfd_error_handler)
1271 (_("%B, section %A: relocation %s is"
1272 " not allowed for global symbol: `%s'"),
1273 input_bfd,
1274 input_section,
1275 cris_elf_howto_table[r_type].name,
1276 symname);
1277 bfd_set_error (bfd_error_bad_value);
1278 return FALSE;
1279 }
1280
1281 /* This can happen if we get a link error with the input ELF
1282 variant mismatching the output variant. Emit an error so
1283 it's noticed if it happens elsewhere. */
1284 if (sgot == NULL)
1285 {
1286 (*_bfd_error_handler)
1287 (_("%B, section %A: relocation %s with no GOT created"),
1288 input_bfd,
1289 input_section,
1290 cris_elf_howto_table[r_type].name);
1291 bfd_set_error (bfd_error_bad_value);
1292 return FALSE;
1293 }
1294
1295 /* This relocation is like a PC-relative one, except the
1296 reference point is the location of GOT. Note that
1297 sgot->output_offset is not involved in this calculation. We
1298 always want the start of entire .got section, not the
1299 position after the reserved header. */
1300 relocation -= sgot->output_section->vma;
1301 break;
1302
1303 case R_CRIS_32_PLT_PCREL:
1304 /* Relocation is to the entry for this symbol in the
1305 procedure linkage table. */
1306
1307 /* Resolve a PLT_PCREL reloc against a local symbol directly,
1308 without using the procedure linkage table. */
1309 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1310 break;
1311
1312 if (h->plt.offset == (bfd_vma) -1
1313 || splt == NULL)
1314 {
1315 /* We didn't make a PLT entry for this symbol. This
1316 happens when statically linking PIC code, or when
1317 using -Bsymbolic. */
1318 break;
1319 }
1320
1321 relocation = (splt->output_section->vma
1322 + splt->output_offset
1323 + h->plt.offset);
1324 break;
1325
1326 case R_CRIS_32_PLT_GOTREL:
1327 /* Like R_CRIS_32_PLT_PCREL, but the reference point is the
1328 start of the .got section. See also comment at
1329 R_CRIS_32_GOT. */
1330 relocation -= sgot->output_section->vma;
1331
1332 /* Resolve a PLT_GOTREL reloc against a local symbol directly,
1333 without using the procedure linkage table. */
1334 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1335 break;
1336
1337 if (h->plt.offset == (bfd_vma) -1
1338 || splt == NULL)
1339 {
1340 /* We didn't make a PLT entry for this symbol. This
1341 happens when statically linking PIC code, or when
1342 using -Bsymbolic. */
1343 break;
1344 }
1345
1346 relocation = (splt->output_section->vma
1347 + splt->output_offset
1348 + h->plt.offset
1349 - sgot->output_section->vma);
1350 break;
1351
1352 case R_CRIS_8_PCREL:
1353 case R_CRIS_16_PCREL:
1354 case R_CRIS_32_PCREL:
1355 /* If the symbol was local, we need no shlib-specific handling. */
1356 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1357 break;
1358
1359 /* Fall through. */
1360 case R_CRIS_8:
1361 case R_CRIS_16:
1362 case R_CRIS_32:
1363 if (info->shared
1364 && r_symndx != 0
1365 && (input_section->flags & SEC_ALLOC) != 0
1366 && ((r_type != R_CRIS_8_PCREL
1367 && r_type != R_CRIS_16_PCREL
1368 && r_type != R_CRIS_32_PCREL)
1369 || (!info->symbolic
1370 || !h->def_regular)))
1371 {
1372 Elf_Internal_Rela outrel;
1373 bfd_byte *loc;
1374 bfd_boolean skip, relocate;
1375
1376 /* When generating a shared object, these relocations
1377 are copied into the output file to be resolved at run
1378 time. */
1379
1380 if (sreloc == NULL)
1381 {
1382 const char *name;
1383
1384 name = (bfd_elf_string_from_elf_section
1385 (input_bfd,
1386 elf_elfheader (input_bfd)->e_shstrndx,
1387 elf_section_data (input_section)->rel_hdr.sh_name));
1388 if (name == NULL)
1389 return FALSE;
1390
1391 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1392 && strcmp (bfd_get_section_name (input_bfd,
1393 input_section),
1394 name + 5) == 0);
1395
1396 sreloc = bfd_get_section_by_name (dynobj, name);
1397
1398 /* That section should have been created in
1399 cris_elf_check_relocs, but that function will not be
1400 called for objects which fail in
1401 cris_elf_merge_private_bfd_data. */
1402 if (sreloc == NULL)
1403 {
1404 (*_bfd_error_handler)
1405 (_("%B: Internal inconsistency; no relocation section %s"),
1406 input_bfd,
1407 name);
1408
1409 bfd_set_error (bfd_error_bad_value);
1410 return FALSE;
1411 }
1412 }
1413
1414 skip = FALSE;
1415 relocate = FALSE;
1416
1417 outrel.r_offset =
1418 _bfd_elf_section_offset (output_bfd, info, input_section,
1419 rel->r_offset);
1420 if (outrel.r_offset == (bfd_vma) -1)
1421 skip = TRUE;
1422 else if (outrel.r_offset == (bfd_vma) -2)
1423 skip = TRUE, relocate = TRUE;
1424 outrel.r_offset += (input_section->output_section->vma
1425 + input_section->output_offset);
1426
1427 if (skip)
1428 memset (&outrel, 0, sizeof outrel);
1429 /* h->dynindx may be -1 if the symbol was marked to
1430 become local. */
1431 else if (h != NULL
1432 && ((! info->symbolic && h->dynindx != -1)
1433 || !h->def_regular))
1434 {
1435 BFD_ASSERT (h->dynindx != -1);
1436 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1437 outrel.r_addend = relocation + rel->r_addend;
1438 }
1439 else
1440 {
1441 if (r_type == R_CRIS_32)
1442 {
1443 relocate = TRUE;
1444 outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1445 outrel.r_addend = relocation + rel->r_addend;
1446 }
1447 else
1448 {
1449 long indx;
1450
1451 if (bfd_is_abs_section (sec))
1452 indx = 0;
1453 else if (sec == NULL || sec->owner == NULL)
1454 {
1455 bfd_set_error (bfd_error_bad_value);
1456 return FALSE;
1457 }
1458 else
1459 {
1460 asection *osec;
1461
1462 osec = sec->output_section;
1463 indx = elf_section_data (osec)->dynindx;
1464 BFD_ASSERT (indx > 0);
1465 }
1466
1467 outrel.r_info = ELF32_R_INFO (indx, r_type);
1468 outrel.r_addend = relocation + rel->r_addend;
1469 }
1470 }
1471
1472 loc = sreloc->contents;
1473 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1474 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1475
1476 /* This reloc will be computed at runtime, so there's no
1477 need to do anything now, except for R_CRIS_32 relocations
1478 that have been turned into R_CRIS_RELATIVE. */
1479 if (!relocate)
1480 continue;
1481 }
1482
1483 break;
1484 }
1485
1486 r = cris_final_link_relocate (howto, input_bfd, input_section,
1487 contents, rel, relocation);
1488
1489 if (r != bfd_reloc_ok)
1490 {
1491 const char * msg = (const char *) NULL;
1492
1493 switch (r)
1494 {
1495 case bfd_reloc_overflow:
1496 r = info->callbacks->reloc_overflow
1497 (info, (h ? &h->root : NULL), symname, howto->name,
1498 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1499 break;
1500
1501 case bfd_reloc_undefined:
1502 r = info->callbacks->undefined_symbol
1503 (info, symname, input_bfd, input_section, rel->r_offset,
1504 TRUE);
1505 break;
1506
1507 case bfd_reloc_outofrange:
1508 msg = _("internal error: out of range error");
1509 break;
1510
1511 case bfd_reloc_notsupported:
1512 msg = _("internal error: unsupported relocation error");
1513 break;
1514
1515 case bfd_reloc_dangerous:
1516 msg = _("internal error: dangerous relocation");
1517 break;
1518
1519 default:
1520 msg = _("internal error: unknown error");
1521 break;
1522 }
1523
1524 if (msg)
1525 r = info->callbacks->warning
1526 (info, msg, symname, input_bfd, input_section, rel->r_offset);
1527
1528 if (! r)
1529 return FALSE;
1530 }
1531 }
1532
1533 return TRUE;
1534 }
1535 \f
1536 /* Finish up dynamic symbol handling. We set the contents of various
1537 dynamic sections here. */
1538
1539 static bfd_boolean
1540 elf_cris_finish_dynamic_symbol (output_bfd, info, h, sym)
1541 bfd *output_bfd;
1542 struct bfd_link_info *info;
1543 struct elf_link_hash_entry *h;
1544 Elf_Internal_Sym *sym;
1545 {
1546 bfd *dynobj;
1547
1548 /* Where in the plt entry to put values. */
1549 int plt_off1 = 2, plt_off2 = 10, plt_off3 = 16;
1550
1551 /* What offset to add to the distance to the first PLT entry for the
1552 value at plt_off3. */
1553 int plt_off3_value_bias = 4;
1554
1555 /* Where in the PLT entry the call-dynlink-stub is (happens to be same
1556 for PIC and non-PIC for v32 and pre-v32). */
1557 int plt_stub_offset = 8;
1558 int plt_entry_size = PLT_ENTRY_SIZE;
1559 const bfd_byte *plt_entry = elf_cris_plt_entry;
1560 const bfd_byte *plt_pic_entry = elf_cris_pic_plt_entry;
1561
1562 /* Adjust the various PLT entry offsets. */
1563 if (bfd_get_mach (output_bfd) == bfd_mach_cris_v32)
1564 {
1565 plt_off2 = 14;
1566 plt_off3 = 20;
1567 plt_off3_value_bias = -2;
1568 plt_stub_offset = 12;
1569 plt_entry_size = PLT_ENTRY_SIZE_V32;
1570 plt_entry = elf_cris_plt_entry_v32;
1571 plt_pic_entry = elf_cris_pic_plt_entry_v32;
1572 }
1573
1574 dynobj = elf_hash_table (info)->dynobj;
1575
1576 if (h->plt.offset != (bfd_vma) -1)
1577 {
1578 asection *splt;
1579 asection *sgotplt;
1580 asection *sgot;
1581 asection *srela;
1582 bfd_vma got_base;
1583
1584 bfd_vma gotplt_offset
1585 = ((struct elf_cris_link_hash_entry *) h)->gotplt_offset;
1586 Elf_Internal_Rela rela;
1587 bfd_byte *loc;
1588 bfd_boolean has_gotplt = gotplt_offset != 0;
1589
1590 /* Get the index in the procedure linkage table which
1591 corresponds to this symbol. This is the index of this symbol
1592 in all the symbols for which we are making plt entries. The
1593 first entry in the procedure linkage table is reserved. */
1594 /* We have to count backwards here, and the result is only valid as
1595 an index into .got.plt and its relocations. FIXME: Constants... */
1596 bfd_vma gotplt_index = gotplt_offset/4 - 3;
1597
1598 /* Get the offset into the .got table of the entry that corresponds
1599 to this function. Note that we embed knowledge that "incoming"
1600 .got goes after .got.plt in the output without padding (pointer
1601 aligned). However, that knowledge is present in several other
1602 places too. */
1603 bfd_vma got_offset
1604 = (has_gotplt
1605 ? gotplt_offset
1606 : h->got.offset + elf_cris_hash_table(info)->next_gotplt_entry);
1607
1608 /* This symbol has an entry in the procedure linkage table. Set it
1609 up. */
1610
1611 BFD_ASSERT (h->dynindx != -1);
1612
1613 splt = bfd_get_section_by_name (dynobj, ".plt");
1614 sgot = bfd_get_section_by_name (dynobj, ".got");
1615 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1616 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1617 BFD_ASSERT (splt != NULL && sgotplt != NULL
1618 && (! has_gotplt || srela != NULL));
1619
1620 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
1621
1622 /* Fill in the entry in the procedure linkage table. */
1623 if (! info->shared)
1624 {
1625 memcpy (splt->contents + h->plt.offset, plt_entry,
1626 plt_entry_size);
1627
1628 /* We need to enter the absolute address of the GOT entry here. */
1629 bfd_put_32 (output_bfd, got_base + got_offset,
1630 splt->contents + h->plt.offset + plt_off1);
1631 }
1632 else
1633 {
1634 memcpy (splt->contents + h->plt.offset, plt_pic_entry,
1635 plt_entry_size);
1636 bfd_put_32 (output_bfd, got_offset,
1637 splt->contents + h->plt.offset + plt_off1);
1638 }
1639
1640 /* Fill in the plt entry and make a relocation, if this is a "real"
1641 PLT entry. */
1642 if (has_gotplt)
1643 {
1644 /* Fill in the offset to the reloc table. */
1645 bfd_put_32 (output_bfd,
1646 gotplt_index * sizeof (Elf32_External_Rela),
1647 splt->contents + h->plt.offset + plt_off2);
1648
1649 /* Fill in the offset to the first PLT entry, where to "jump". */
1650 bfd_put_32 (output_bfd,
1651 - (h->plt.offset + plt_off3 + plt_off3_value_bias),
1652 splt->contents + h->plt.offset + plt_off3);
1653
1654 /* Fill in the entry in the global offset table with the address of
1655 the relocating stub. */
1656 bfd_put_32 (output_bfd,
1657 (splt->output_section->vma
1658 + splt->output_offset
1659 + h->plt.offset
1660 + plt_stub_offset),
1661 sgotplt->contents + got_offset);
1662
1663 /* Fill in the entry in the .rela.plt section. */
1664 rela.r_offset = (sgotplt->output_section->vma
1665 + sgotplt->output_offset
1666 + got_offset);
1667 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_JUMP_SLOT);
1668 rela.r_addend = 0;
1669 loc = srela->contents + gotplt_index * sizeof (Elf32_External_Rela);
1670 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1671 }
1672
1673 if (!h->def_regular)
1674 {
1675 /* Mark the symbol as undefined, rather than as defined in
1676 the .plt section. Leave the value alone. */
1677 sym->st_shndx = SHN_UNDEF;
1678
1679 /* FIXME: From elf32-sparc.c 2001-02-19 (1.18). I still don't
1680 know whether resetting the value is significant; if it really
1681 is, rather than a quirk or bug in the sparc port, then I
1682 believe we'd see this elsewhere. */
1683 /* If the symbol is weak, we do need to clear the value.
1684 Otherwise, the PLT entry would provide a definition for
1685 the symbol even if the symbol wasn't defined anywhere,
1686 and so the symbol would never be NULL. */
1687 if (!h->ref_regular_nonweak)
1688 sym->st_value = 0;
1689 }
1690 }
1691
1692 /* For an ordinary program, we emit .got relocs only for symbols that
1693 are in the dynamic-symbols table and are either defined by the
1694 program or are undefined weak symbols, or are function symbols
1695 where we do not output a PLT: the PLT reloc was output above and all
1696 references to the function symbol are redirected to the PLT. */
1697 if (h->got.offset != (bfd_vma) -1
1698 && (info->shared
1699 || (h->dynindx != -1
1700 && h->plt.offset == (bfd_vma) -1
1701 && !h->def_regular
1702 && h->root.type != bfd_link_hash_undefweak)))
1703 {
1704 asection *sgot;
1705 asection *srela;
1706 Elf_Internal_Rela rela;
1707 bfd_byte *loc;
1708 bfd_byte *where;
1709
1710 /* This symbol has an entry in the global offset table. Set it up. */
1711
1712 sgot = bfd_get_section_by_name (dynobj, ".got");
1713 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1714 BFD_ASSERT (sgot != NULL && srela != NULL);
1715
1716 rela.r_offset = (sgot->output_section->vma
1717 + sgot->output_offset
1718 + (h->got.offset &~ (bfd_vma) 1));
1719
1720 /* If this is a static link, or it is a -Bsymbolic link and the
1721 symbol is defined locally or was forced to be local because
1722 of a version file, we just want to emit a RELATIVE reloc.
1723 The entry in the global offset table will already have been
1724 initialized in the relocate_section function. */
1725 where = sgot->contents + (h->got.offset &~ (bfd_vma) 1);
1726 if (! elf_hash_table (info)->dynamic_sections_created
1727 || (info->shared
1728 && (info->symbolic || h->dynindx == -1)
1729 && h->def_regular))
1730 {
1731 rela.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1732 rela.r_addend = bfd_get_signed_32 (output_bfd, where);
1733 }
1734 else
1735 {
1736 bfd_put_32 (output_bfd, (bfd_vma) 0, where);
1737 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_GLOB_DAT);
1738 rela.r_addend = 0;
1739 }
1740
1741 loc = srela->contents;
1742 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
1743 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1744 }
1745
1746 if (h->needs_copy)
1747 {
1748 asection *s;
1749 Elf_Internal_Rela rela;
1750 bfd_byte *loc;
1751
1752 /* This symbol needs a copy reloc. Set it up. */
1753
1754 BFD_ASSERT (h->dynindx != -1
1755 && (h->root.type == bfd_link_hash_defined
1756 || h->root.type == bfd_link_hash_defweak));
1757
1758 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1759 ".rela.bss");
1760 BFD_ASSERT (s != NULL);
1761
1762 rela.r_offset = (h->root.u.def.value
1763 + h->root.u.def.section->output_section->vma
1764 + h->root.u.def.section->output_offset);
1765 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_COPY);
1766 rela.r_addend = 0;
1767 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
1768 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1769 }
1770
1771 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1772 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1773 || h == elf_hash_table (info)->hgot)
1774 sym->st_shndx = SHN_ABS;
1775
1776 return TRUE;
1777 }
1778 \f
1779 /* Finish up the dynamic sections. */
1780
1781 static bfd_boolean
1782 elf_cris_finish_dynamic_sections (output_bfd, info)
1783 bfd *output_bfd;
1784 struct bfd_link_info *info;
1785 {
1786 bfd *dynobj;
1787 asection *sgot;
1788 asection *sdyn;
1789
1790 dynobj = elf_hash_table (info)->dynobj;
1791
1792 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1793 BFD_ASSERT (sgot != NULL);
1794 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1795
1796 if (elf_hash_table (info)->dynamic_sections_created)
1797 {
1798 asection *splt;
1799 Elf32_External_Dyn *dyncon, *dynconend;
1800
1801 splt = bfd_get_section_by_name (dynobj, ".plt");
1802 BFD_ASSERT (splt != NULL && sdyn != NULL);
1803
1804 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1805 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1806 for (; dyncon < dynconend; dyncon++)
1807 {
1808 Elf_Internal_Dyn dyn;
1809 asection *s;
1810
1811 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1812
1813 switch (dyn.d_tag)
1814 {
1815 default:
1816 break;
1817
1818 case DT_PLTGOT:
1819 s = bfd_get_section_by_name (output_bfd, ".got");
1820 BFD_ASSERT (s != NULL);
1821 dyn.d_un.d_ptr = s->vma;
1822 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1823 break;
1824
1825 case DT_JMPREL:
1826 /* Yes, we *can* have a .plt and no .plt.rela, for instance
1827 if all symbols are found in the .got (not .got.plt). */
1828 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1829 dyn.d_un.d_ptr = s != NULL ? s->vma : 0;
1830 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1831 break;
1832
1833 case DT_PLTRELSZ:
1834 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1835 if (s == NULL)
1836 dyn.d_un.d_val = 0;
1837 else
1838 dyn.d_un.d_val = s->size;
1839 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1840 break;
1841
1842 case DT_RELASZ:
1843 /* The procedure linkage table relocs (DT_JMPREL) should
1844 not be included in the overall relocs (DT_RELA).
1845 Therefore, we override the DT_RELASZ entry here to
1846 make it not include the JMPREL relocs. Since the
1847 linker script arranges for .rela.plt to follow all
1848 other relocation sections, we don't have to worry
1849 about changing the DT_RELA entry. */
1850 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1851 if (s != NULL)
1852 dyn.d_un.d_val -= s->size;
1853 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1854 break;
1855 }
1856 }
1857
1858 /* Fill in the first entry in the procedure linkage table. */
1859 if (splt->size > 0)
1860 {
1861 if (bfd_get_mach (output_bfd) == bfd_mach_cris_v32)
1862 {
1863 if (info->shared)
1864 memcpy (splt->contents, elf_cris_pic_plt0_entry_v32,
1865 PLT_ENTRY_SIZE_V32);
1866 else
1867 {
1868 memcpy (splt->contents, elf_cris_plt0_entry_v32,
1869 PLT_ENTRY_SIZE_V32);
1870 bfd_put_32 (output_bfd,
1871 sgot->output_section->vma
1872 + sgot->output_offset + 4,
1873 splt->contents + 4);
1874
1875 elf_section_data (splt->output_section)->this_hdr.sh_entsize
1876 = PLT_ENTRY_SIZE_V32;
1877 }
1878 }
1879 else
1880 {
1881 if (info->shared)
1882 memcpy (splt->contents, elf_cris_pic_plt0_entry,
1883 PLT_ENTRY_SIZE);
1884 else
1885 {
1886 memcpy (splt->contents, elf_cris_plt0_entry,
1887 PLT_ENTRY_SIZE);
1888 bfd_put_32 (output_bfd,
1889 sgot->output_section->vma
1890 + sgot->output_offset + 4,
1891 splt->contents + 6);
1892 bfd_put_32 (output_bfd,
1893 sgot->output_section->vma
1894 + sgot->output_offset + 8,
1895 splt->contents + 14);
1896
1897 elf_section_data (splt->output_section)->this_hdr.sh_entsize
1898 = PLT_ENTRY_SIZE;
1899 }
1900 }
1901 }
1902 }
1903
1904 /* Fill in the first three entries in the global offset table. */
1905 if (sgot->size > 0)
1906 {
1907 if (sdyn == NULL)
1908 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1909 else
1910 bfd_put_32 (output_bfd,
1911 sdyn->output_section->vma + sdyn->output_offset,
1912 sgot->contents);
1913 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1914 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1915 }
1916
1917 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1918
1919 return TRUE;
1920 }
1921 \f
1922 /* Return the section that should be marked against GC for a given
1923 relocation. */
1924
1925 static asection *
1926 cris_elf_gc_mark_hook (sec, info, rel, h, sym)
1927 asection *sec;
1928 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1929 Elf_Internal_Rela *rel;
1930 struct elf_link_hash_entry *h;
1931 Elf_Internal_Sym *sym;
1932 {
1933 if (h != NULL)
1934 {
1935 switch (ELF32_R_TYPE (rel->r_info))
1936 {
1937 case R_CRIS_GNU_VTINHERIT:
1938 case R_CRIS_GNU_VTENTRY:
1939 break;
1940
1941 default:
1942 switch (h->root.type)
1943 {
1944 case bfd_link_hash_defined:
1945 case bfd_link_hash_defweak:
1946 return h->root.u.def.section;
1947
1948 case bfd_link_hash_common:
1949 return h->root.u.c.p->section;
1950
1951 default:
1952 break;
1953 }
1954 }
1955 }
1956 else
1957 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1958
1959 return NULL;
1960 }
1961
1962 /* Update the got entry reference counts for the section being removed. */
1963
1964 static bfd_boolean
1965 cris_elf_gc_sweep_hook (abfd, info, sec, relocs)
1966 bfd *abfd ATTRIBUTE_UNUSED;
1967 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1968 asection *sec ATTRIBUTE_UNUSED;
1969 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
1970 {
1971 Elf_Internal_Shdr *symtab_hdr;
1972 struct elf_link_hash_entry **sym_hashes;
1973 bfd_signed_vma *local_got_refcounts;
1974 const Elf_Internal_Rela *rel, *relend;
1975 bfd *dynobj;
1976 asection *sgot;
1977 asection *srelgot;
1978
1979 dynobj = elf_hash_table (info)->dynobj;
1980 if (dynobj == NULL)
1981 return TRUE;
1982
1983 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1984 sym_hashes = elf_sym_hashes (abfd);
1985 local_got_refcounts = elf_local_got_refcounts (abfd);
1986
1987 sgot = bfd_get_section_by_name (dynobj, ".got");
1988 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1989
1990 relend = relocs + sec->reloc_count;
1991 for (rel = relocs; rel < relend; rel++)
1992 {
1993 unsigned long r_symndx;
1994 struct elf_link_hash_entry *h = NULL;
1995
1996 r_symndx = ELF32_R_SYM (rel->r_info);
1997 if (r_symndx >= symtab_hdr->sh_info)
1998 {
1999 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2000 while (h->root.type == bfd_link_hash_indirect
2001 || h->root.type == bfd_link_hash_warning)
2002 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2003 }
2004
2005 switch (ELF32_R_TYPE (rel->r_info))
2006 {
2007 case R_CRIS_16_GOT:
2008 case R_CRIS_32_GOT:
2009 if (h != NULL)
2010 {
2011 if (h->got.refcount > 0)
2012 {
2013 --h->got.refcount;
2014 if (h->got.refcount == 0)
2015 {
2016 /* We don't need the .got entry any more. */
2017 sgot->size -= 4;
2018 srelgot->size -= sizeof (Elf32_External_Rela);
2019 }
2020 }
2021 break;
2022 }
2023
2024 local_got_reloc:
2025 if (local_got_refcounts != NULL)
2026 {
2027 if (local_got_refcounts[r_symndx] > 0)
2028 {
2029 --local_got_refcounts[r_symndx];
2030 if (local_got_refcounts[r_symndx] == 0)
2031 {
2032 /* We don't need the .got entry any more. */
2033 sgot->size -= 4;
2034 if (info->shared)
2035 srelgot->size -= sizeof (Elf32_External_Rela);
2036 }
2037 }
2038 }
2039 break;
2040
2041 case R_CRIS_16_GOTPLT:
2042 case R_CRIS_32_GOTPLT:
2043 /* For local symbols, treat these like GOT relocs. */
2044 if (h == NULL)
2045 goto local_got_reloc;
2046 /* Fall through. */
2047
2048 case R_CRIS_32_PLT_GOTREL:
2049 /* FIXME: We don't garbage-collect away the .got section. */
2050 if (local_got_refcounts != NULL)
2051 local_got_refcounts[-1]--;
2052 /* Fall through. */
2053
2054 case R_CRIS_8_PCREL:
2055 case R_CRIS_16_PCREL:
2056 case R_CRIS_32_PCREL:
2057 case R_CRIS_32_PLT_PCREL:
2058 if (h != NULL)
2059 {
2060 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2061 && h->plt.refcount > 0)
2062 --h->plt.refcount;
2063 }
2064 break;
2065
2066 default:
2067 break;
2068 }
2069 }
2070
2071 return TRUE;
2072 }
2073
2074 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
2075 entry but we found we will not create any. Called when we find we will
2076 not have any PLT for this symbol, by for example
2077 elf_cris_adjust_dynamic_symbol when we're doing a proper dynamic link,
2078 or elf_cris_size_dynamic_sections if no dynamic sections will be
2079 created (we're only linking static objects). */
2080
2081 static bfd_boolean
2082 elf_cris_adjust_gotplt_to_got (h, p)
2083 struct elf_cris_link_hash_entry *h;
2084 PTR p;
2085 {
2086 struct bfd_link_info *info = (struct bfd_link_info *) p;
2087
2088 if (h->root.root.type == bfd_link_hash_warning)
2089 h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
2090
2091 /* If nobody wanted a GOTPLT with this symbol, we're done. */
2092 if (h->gotplt_refcount <= 0)
2093 return TRUE;
2094
2095 if (h->root.got.refcount > 0)
2096 {
2097 /* There's a GOT entry for this symbol. Just adjust the refcount.
2098 Probably not necessary at this stage, but keeping it accurate
2099 helps avoiding surprises later. */
2100 h->root.got.refcount += h->gotplt_refcount;
2101 h->gotplt_refcount = 0;
2102 }
2103 else
2104 {
2105 /* No GOT entry for this symbol. We need to create one. */
2106 bfd *dynobj = elf_hash_table (info)->dynobj;
2107 asection *sgot;
2108 asection *srelgot;
2109
2110 BFD_ASSERT (dynobj != NULL);
2111 sgot = bfd_get_section_by_name (dynobj, ".got");
2112 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2113
2114 /* Put an accurate refcount there. */
2115 h->root.got.refcount = h->gotplt_refcount;
2116
2117 h->gotplt_refcount = 0;
2118
2119 /* We always have a .got and a .rela.got section if there were
2120 GOTPLT relocs in input. */
2121 BFD_ASSERT (sgot != NULL && srelgot != NULL);
2122
2123 /* Allocate space in the .got section. */
2124 sgot->size += 4;
2125
2126 /* Allocate relocation space. */
2127 srelgot->size += sizeof (Elf32_External_Rela);
2128 }
2129
2130 return TRUE;
2131 }
2132
2133 /* Try to fold PLT entries with GOT entries. There are two cases when we
2134 want to do this:
2135
2136 - When all PLT references are GOTPLT references, and there are GOT
2137 references, and this is not the executable. We don't have to
2138 generate a PLT at all.
2139
2140 - When there are both (ordinary) PLT references and GOT references,
2141 and this isn't the executable.
2142 We want to make the PLT reference use the ordinary GOT entry rather
2143 than R_CRIS_JUMP_SLOT, a run-time dynamically resolved GOTPLT entry,
2144 since the GOT entry will have to be resolved at startup anyway.
2145
2146 Though the latter case is handled when room for the PLT is allocated,
2147 not here.
2148
2149 By folding into the GOT, we may need a round-trip to a PLT in the
2150 executable for calls, a loss in performance. Still, losing a
2151 reloc is a win in size and at least in start-up time.
2152
2153 Note that this function is called before symbols are forced local by
2154 version scripts. The differing cases are handled by
2155 elf_cris_hide_symbol. */
2156
2157 static bfd_boolean
2158 elf_cris_try_fold_plt_to_got (h, p)
2159 struct elf_cris_link_hash_entry *h;
2160 PTR p;
2161 {
2162 struct bfd_link_info *info = (struct bfd_link_info *) p;
2163
2164 /* If there are no GOT references for this symbol, we can't fold any
2165 other reference so there's nothing to do. Likewise if there are no
2166 PLT references; GOTPLT references included. */
2167 if (h->root.got.refcount <= 0 || h->root.plt.refcount <= 0)
2168 return TRUE;
2169
2170 /* GOTPLT relocs are supposed to be included into the PLT refcount. */
2171 BFD_ASSERT (h->gotplt_refcount <= h->root.plt.refcount);
2172
2173 if (h->gotplt_refcount == h->root.plt.refcount)
2174 {
2175 /* The only PLT references are GOTPLT references, and there are GOT
2176 references. Convert PLT to GOT references. */
2177 if (! elf_cris_adjust_gotplt_to_got (h, info))
2178 return FALSE;
2179
2180 /* Clear the PLT references, so no PLT will be created. */
2181 h->root.plt.offset = (bfd_vma) -1;
2182 }
2183
2184 return TRUE;
2185 }
2186
2187 /* Our own version of hide_symbol, so that we can adjust a GOTPLT reloc
2188 to use a GOT entry (and create one) rather than requiring a GOTPLT
2189 entry. */
2190
2191 static void
2192 elf_cris_hide_symbol (info, h, force_local)
2193 struct bfd_link_info *info;
2194 struct elf_link_hash_entry *h;
2195 bfd_boolean force_local;
2196 {
2197 elf_cris_adjust_gotplt_to_got ((struct elf_cris_link_hash_entry *) h, info);
2198
2199 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
2200 }
2201
2202 /* Adjust a symbol defined by a dynamic object and referenced by a
2203 regular object. The current definition is in some section of the
2204 dynamic object, but we're not including those sections. We have to
2205 change the definition to something the rest of the link can
2206 understand. */
2207
2208 static bfd_boolean
2209 elf_cris_adjust_dynamic_symbol (info, h)
2210 struct bfd_link_info *info;
2211 struct elf_link_hash_entry *h;
2212 {
2213 bfd *dynobj;
2214 asection *s;
2215 unsigned int power_of_two;
2216 bfd_size_type plt_entry_size;
2217
2218 dynobj = elf_hash_table (info)->dynobj;
2219
2220 /* Make sure we know what is going on here. */
2221 BFD_ASSERT (dynobj != NULL
2222 && (h->needs_plt
2223 || h->u.weakdef != NULL
2224 || (h->def_dynamic
2225 && h->ref_regular
2226 && !h->def_regular)));
2227
2228 plt_entry_size
2229 = (bfd_get_mach (dynobj) == bfd_mach_cris_v32
2230 ? PLT_ENTRY_SIZE_V32 : PLT_ENTRY_SIZE);
2231
2232 /* If this is a function, put it in the procedure linkage table. We
2233 will fill in the contents of the procedure linkage table later,
2234 when we know the address of the .got section. */
2235 if (h->type == STT_FUNC
2236 || h->needs_plt)
2237 {
2238 /* If we link a program (not a DSO), we'll get rid of unnecessary
2239 PLT entries; we point to the actual symbols -- even for pic
2240 relocs, because a program built with -fpic should have the same
2241 result as one built without -fpic, specifically considering weak
2242 symbols.
2243 FIXME: m68k and i386 differ here, for unclear reasons. */
2244 if (! info->shared
2245 && !h->def_dynamic)
2246 {
2247 /* This case can occur if we saw a PLT reloc in an input file,
2248 but the symbol was not defined by a dynamic object. In such
2249 a case, we don't actually need to build a procedure linkage
2250 table, and we can just do an absolute or PC reloc instead, or
2251 change a .got.plt index to a .got index for GOTPLT relocs. */
2252 BFD_ASSERT (h->needs_plt);
2253 h->needs_plt = 0;
2254 h->plt.offset = (bfd_vma) -1;
2255 return
2256 elf_cris_adjust_gotplt_to_got ((struct
2257 elf_cris_link_hash_entry *) h,
2258 info);
2259 }
2260
2261 /* If we had a R_CRIS_GLOB_DAT that didn't have to point to a PLT;
2262 where a pointer-equivalent symbol was unimportant (i.e. more
2263 like R_CRIS_JUMP_SLOT after symbol evaluation) we could get rid
2264 of the PLT. We can't for the executable, because the GOT
2265 entries will point to the PLT there (and be constant). */
2266 if (info->shared
2267 && !elf_cris_try_fold_plt_to_got ((struct elf_cris_link_hash_entry*)
2268 h, info))
2269 return FALSE;
2270
2271 /* GC or folding may have rendered this entry unused. */
2272 if (h->plt.refcount <= 0)
2273 {
2274 h->needs_plt = 0;
2275 h->plt.offset = (bfd_vma) -1;
2276 return TRUE;
2277 }
2278
2279 /* Make sure this symbol is output as a dynamic symbol. */
2280 if (h->dynindx == -1)
2281 {
2282 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2283 return FALSE;
2284 }
2285
2286 s = bfd_get_section_by_name (dynobj, ".plt");
2287 BFD_ASSERT (s != NULL);
2288
2289 /* If this is the first .plt entry, make room for the special
2290 first entry. */
2291 if (s->size == 0)
2292 s->size += plt_entry_size;
2293
2294 /* If this symbol is not defined in a regular file, and we are
2295 not generating a shared library, then set the symbol to this
2296 location in the .plt. */
2297 if (!info->shared
2298 && !h->def_regular)
2299 {
2300 h->root.u.def.section = s;
2301 h->root.u.def.value = s->size;
2302 }
2303
2304 /* If there's already a GOT entry, use that, not a .got.plt. A
2305 GOT field still has a reference count when we get here; it's
2306 not yet changed to an offset. We can't do this for an
2307 executable, because then the reloc associated with the PLT
2308 would get a non-PLT reloc pointing to the PLT. FIXME: Move
2309 this to elf_cris_try_fold_plt_to_got. */
2310 if (info->shared && h->got.refcount > 0)
2311 {
2312 h->got.refcount += h->plt.refcount;
2313
2314 /* Mark the PLT offset to use the GOT entry by setting the low
2315 bit in the plt offset; it is always a multiple of
2316 plt_entry_size (which is at least a multiple of 2). */
2317 BFD_ASSERT ((s->size % plt_entry_size) == 0);
2318
2319 /* Change the PLT refcount to an offset. */
2320 h->plt.offset = s->size;
2321
2322 /* By not setting gotplt_offset (i.e. it remains at 0), we signal
2323 that the got entry should be used instead. */
2324 BFD_ASSERT (((struct elf_cris_link_hash_entry *)
2325 h)->gotplt_offset == 0);
2326
2327 /* Make room for this entry. */
2328 s->size += plt_entry_size;
2329
2330 return TRUE;
2331 }
2332
2333 /* No GOT reference for this symbol; prepare for an ordinary PLT. */
2334 h->plt.offset = s->size;
2335
2336 /* Make room for this entry. */
2337 s->size += plt_entry_size;
2338
2339 /* We also need to make an entry in the .got.plt section, which
2340 will be placed in the .got section by the linker script. */
2341 ((struct elf_cris_link_hash_entry *) h)->gotplt_offset
2342 = elf_cris_hash_table (info)->next_gotplt_entry;
2343 elf_cris_hash_table (info)->next_gotplt_entry += 4;
2344
2345 s = bfd_get_section_by_name (dynobj, ".got.plt");
2346 BFD_ASSERT (s != NULL);
2347 s->size += 4;
2348
2349 /* We also need to make an entry in the .rela.plt section. */
2350
2351 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2352 BFD_ASSERT (s != NULL);
2353 s->size += sizeof (Elf32_External_Rela);
2354
2355 return TRUE;
2356 }
2357
2358 /* Reinitialize the plt offset now that it is not used as a reference
2359 count any more. */
2360 h->plt.offset = (bfd_vma) -1;
2361
2362 /* If this is a weak symbol, and there is a real definition, the
2363 processor independent code will have arranged for us to see the
2364 real definition first, and we can just use the same value. */
2365 if (h->u.weakdef != NULL)
2366 {
2367 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2368 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2369 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2370 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2371 return TRUE;
2372 }
2373
2374 /* This is a reference to a symbol defined by a dynamic object which
2375 is not a function. */
2376
2377 /* If we are creating a shared library, we must presume that the
2378 only references to the symbol are via the global offset table.
2379 For such cases we need not do anything here; the relocations will
2380 be handled correctly by relocate_section. */
2381 if (info->shared)
2382 return TRUE;
2383
2384 /* If there are no references to this symbol that do not use the
2385 GOT, we don't need to generate a copy reloc. */
2386 if (!h->non_got_ref)
2387 return TRUE;
2388
2389 if (h->size == 0)
2390 {
2391 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
2392 h->root.root.string);
2393 return TRUE;
2394 }
2395
2396 /* We must allocate the symbol in our .dynbss section, which will
2397 become part of the .bss section of the executable. There will be
2398 an entry for this symbol in the .dynsym section. The dynamic
2399 object will contain position independent code, so all references
2400 from the dynamic object to this symbol will go through the global
2401 offset table. The dynamic linker will use the .dynsym entry to
2402 determine the address it must put in the global offset table, so
2403 both the dynamic object and the regular object will refer to the
2404 same memory location for the variable. */
2405
2406 s = bfd_get_section_by_name (dynobj, ".dynbss");
2407 BFD_ASSERT (s != NULL);
2408
2409 /* We must generate a R_CRIS_COPY reloc to tell the dynamic linker to
2410 copy the initial value out of the dynamic object and into the
2411 runtime process image. We need to remember the offset into the
2412 .rela.bss section we are going to use. */
2413 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2414 {
2415 asection *srel;
2416
2417 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
2418 BFD_ASSERT (srel != NULL);
2419 srel->size += sizeof (Elf32_External_Rela);
2420 h->needs_copy = 1;
2421 }
2422
2423 /* Historic precedent: m68k and i386 allow max 8-byte alignment for the
2424 thing to copy; so do we. */
2425
2426 /* We need to figure out the alignment required for this symbol. I
2427 have no idea how ELF linkers handle this. */
2428 power_of_two = bfd_log2 (h->size);
2429 if (power_of_two > 3)
2430 power_of_two = 3;
2431
2432 /* Apply the required alignment. */
2433 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
2434 if (power_of_two > bfd_get_section_alignment (dynobj, s))
2435 {
2436 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
2437 return FALSE;
2438 }
2439
2440 /* Define the symbol as being at this point in the section. */
2441 h->root.u.def.section = s;
2442 h->root.u.def.value = s->size;
2443
2444 /* Increment the section size to make room for the symbol. */
2445 s->size += h->size;
2446
2447 return TRUE;
2448 }
2449
2450 /* Look through the relocs for a section during the first phase. */
2451
2452 static bfd_boolean
2453 cris_elf_check_relocs (abfd, info, sec, relocs)
2454 bfd *abfd;
2455 struct bfd_link_info *info;
2456 asection *sec;
2457 const Elf_Internal_Rela *relocs;
2458 {
2459 bfd *dynobj;
2460 Elf_Internal_Shdr *symtab_hdr;
2461 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2462 bfd_signed_vma *local_got_refcounts;
2463 const Elf_Internal_Rela *rel;
2464 const Elf_Internal_Rela *rel_end;
2465 asection *sgot;
2466 asection *srelgot;
2467 asection *sreloc;
2468
2469 if (info->relocatable)
2470 return TRUE;
2471
2472 dynobj = elf_hash_table (info)->dynobj;
2473 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2474 sym_hashes = elf_sym_hashes (abfd);
2475 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
2476 local_got_refcounts = elf_local_got_refcounts (abfd);
2477
2478 sgot = NULL;
2479 srelgot = NULL;
2480 sreloc = NULL;
2481
2482 if (!elf_bad_symtab (abfd))
2483 sym_hashes_end -= symtab_hdr->sh_info;
2484
2485 rel_end = relocs + sec->reloc_count;
2486 for (rel = relocs; rel < rel_end; rel++)
2487 {
2488 struct elf_link_hash_entry *h;
2489 unsigned long r_symndx;
2490 enum elf_cris_reloc_type r_type;
2491
2492 r_symndx = ELF32_R_SYM (rel->r_info);
2493 if (r_symndx < symtab_hdr->sh_info)
2494 h = NULL;
2495 else
2496 {
2497 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2498 while (h->root.type == bfd_link_hash_indirect
2499 || h->root.type == bfd_link_hash_warning)
2500 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2501 }
2502
2503 r_type = ELF32_R_TYPE (rel->r_info);
2504
2505 /* Some relocs require linker-created sections; we need to hang them
2506 on the first input bfd we found that contained dynamic relocs. */
2507 switch (r_type)
2508 {
2509 case R_CRIS_16_GOT:
2510 case R_CRIS_32_GOT:
2511 case R_CRIS_32_GOTREL:
2512 case R_CRIS_32_PLT_GOTREL:
2513 case R_CRIS_32_PLT_PCREL:
2514 case R_CRIS_16_GOTPLT:
2515 case R_CRIS_32_GOTPLT:
2516 if (dynobj == NULL)
2517 {
2518 elf_hash_table (info)->dynobj = dynobj = abfd;
2519
2520 /* We could handle this if we can get a handle on the
2521 output bfd in elf_cris_adjust_dynamic_symbol. Failing
2522 that, we must insist on dynobj being a specific mach. */
2523 if (bfd_get_mach (dynobj) == bfd_mach_cris_v10_v32)
2524 {
2525 (*_bfd_error_handler)
2526 (_("%B, section %A:\n v10/v32 compatible object %s"
2527 " must not contain a PIC relocation"),
2528 abfd, sec);
2529 return FALSE;
2530 }
2531
2532 /* Create the .got section, so we can assume it's always
2533 present whenever there's a dynobj. */
2534 if (!_bfd_elf_create_got_section (dynobj, info))
2535 return FALSE;
2536 }
2537 break;
2538
2539 default:
2540 break;
2541 }
2542
2543 /* Some relocs require a global offset table (but perhaps not a
2544 specific GOT entry). */
2545 switch (r_type)
2546 {
2547 /* For R_CRIS_16_GOTPLT and R_CRIS_32_GOTPLT, we need a GOT
2548 entry only for local symbols. Unfortunately, we don't know
2549 until later on if there's a version script that forces the
2550 symbol local. We must have the .rela.got section in place
2551 before we know if the symbol looks global now, so we need
2552 to treat the reloc just like for R_CRIS_16_GOT and
2553 R_CRIS_32_GOT. */
2554 case R_CRIS_16_GOTPLT:
2555 case R_CRIS_32_GOTPLT:
2556 case R_CRIS_16_GOT:
2557 case R_CRIS_32_GOT:
2558 if (srelgot == NULL
2559 && (h != NULL || info->shared))
2560 {
2561 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2562 if (srelgot == NULL)
2563 {
2564 srelgot = bfd_make_section_with_flags (dynobj,
2565 ".rela.got",
2566 (SEC_ALLOC
2567 | SEC_LOAD
2568 | SEC_HAS_CONTENTS
2569 | SEC_IN_MEMORY
2570 | SEC_LINKER_CREATED
2571 | SEC_READONLY));
2572 if (srelgot == NULL
2573 || !bfd_set_section_alignment (dynobj, srelgot, 2))
2574 return FALSE;
2575 }
2576 }
2577 /* Fall through. */
2578
2579 case R_CRIS_32_GOTREL:
2580 case R_CRIS_32_PLT_GOTREL:
2581 if (sgot == NULL)
2582 sgot = bfd_get_section_by_name (dynobj, ".got");
2583
2584 if (local_got_refcounts == NULL)
2585 {
2586 bfd_size_type amt;
2587
2588 /* We use index local_got_refcounts[-1] to count all
2589 GOT-relative relocations that do not have explicit
2590 GOT entries. */
2591 amt = symtab_hdr->sh_info + 1;
2592 amt *= sizeof (bfd_signed_vma);
2593 local_got_refcounts = ((bfd_signed_vma *) bfd_zalloc (abfd, amt));
2594 if (local_got_refcounts == NULL)
2595 return FALSE;
2596
2597 local_got_refcounts++;
2598 elf_local_got_refcounts (abfd) = local_got_refcounts;
2599 }
2600 break;
2601
2602 default:
2603 break;
2604 }
2605
2606 switch (r_type)
2607 {
2608 case R_CRIS_16_GOTPLT:
2609 case R_CRIS_32_GOTPLT:
2610 /* Mark that we need a GOT entry if the PLT entry (and its GOT
2611 entry) is eliminated. We can only do this for a non-local
2612 symbol. */
2613 if (h != NULL)
2614 {
2615 ((struct elf_cris_link_hash_entry *) h)->gotplt_refcount++;
2616 goto handle_gotplt_reloc;
2617 }
2618 /* If h is NULL then this is a local symbol, and we must make a
2619 GOT entry for it, so handle it like a GOT reloc. */
2620 /* Fall through. */
2621
2622 case R_CRIS_16_GOT:
2623 case R_CRIS_32_GOT:
2624 /* This symbol requires a global offset table entry. */
2625 if (h != NULL)
2626 {
2627 if (h->got.refcount == 0)
2628 {
2629 /* Make sure this symbol is output as a dynamic symbol. */
2630 if (h->dynindx == -1)
2631 {
2632 if (!bfd_elf_link_record_dynamic_symbol (info, h))
2633 return FALSE;
2634 }
2635
2636 /* Allocate space in the .got section. */
2637 sgot->size += 4;
2638 /* Allocate relocation space. */
2639 srelgot->size += sizeof (Elf32_External_Rela);
2640 }
2641 h->got.refcount++;
2642 }
2643 else
2644 {
2645 /* This is a global offset table entry for a local symbol. */
2646 if (local_got_refcounts[r_symndx] == 0)
2647 {
2648 sgot->size += 4;
2649 if (info->shared)
2650 {
2651 /* If we are generating a shared object, we need to
2652 output a R_CRIS_RELATIVE reloc so that the dynamic
2653 linker can adjust this GOT entry. */
2654 srelgot->size += sizeof (Elf32_External_Rela);
2655 }
2656 }
2657 local_got_refcounts[r_symndx]++;
2658 }
2659 break;
2660
2661 case R_CRIS_32_GOTREL:
2662 /* This reference requires a global offset table.
2663 FIXME: The actual refcount isn't used currently; the .got
2664 section can't be removed if there were any references in the
2665 input. */
2666 local_got_refcounts[-1]++;
2667 break;
2668
2669 handle_gotplt_reloc:
2670
2671 case R_CRIS_32_PLT_GOTREL:
2672 /* This reference requires a global offset table. */
2673 local_got_refcounts[-1]++;
2674 /* Fall through. */
2675
2676 case R_CRIS_32_PLT_PCREL:
2677 /* This symbol requires a procedure linkage table entry. We
2678 actually build the entry in adjust_dynamic_symbol,
2679 because this might be a case of linking PIC code which is
2680 never referenced by a dynamic object, in which case we
2681 don't need to generate a procedure linkage table entry
2682 after all. */
2683
2684 /* Beware: if we'd check for visibility of the symbol here
2685 (and not marking the need for a PLT when non-visible), we'd
2686 get into trouble with keeping handling consistent with
2687 regards to relocs found before definition and GOTPLT
2688 handling. Eliminable PLT entries will be dealt with later
2689 anyway. */
2690 if (h == NULL)
2691 continue;
2692
2693 h->needs_plt = 1;
2694 h->plt.refcount++;
2695 break;
2696
2697 case R_CRIS_8:
2698 case R_CRIS_16:
2699 case R_CRIS_32:
2700 /* Let's help debug shared library creation. Any of these
2701 relocs can be used in shared libs, but pages containing them
2702 cannot be shared. Don't warn for sections we don't care
2703 about, such as debug sections or non-constant sections. We
2704 can't help tables of (global) function pointers, for example,
2705 though they must be emitted in a data section to avoid having
2706 impure text sections. */
2707 if (info->shared
2708 && (sec->flags & SEC_ALLOC) != 0
2709 && (sec->flags & SEC_READONLY) != 0)
2710 {
2711 /* FIXME: How do we make this optionally a warning only? */
2712 (*_bfd_error_handler)
2713 (_("%B, section %A:\n relocation %s should not"
2714 " be used in a shared object; recompile with -fPIC"),
2715 abfd,
2716 sec,
2717 cris_elf_howto_table[r_type].name);
2718 }
2719 /* Fall through. */
2720
2721 case R_CRIS_8_PCREL:
2722 case R_CRIS_16_PCREL:
2723 case R_CRIS_32_PCREL:
2724 if (h != NULL)
2725 {
2726 h->non_got_ref = 1;
2727
2728 /* Make sure a plt entry is created for this symbol if it
2729 turns out to be a function defined by a dynamic object. */
2730 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2731 h->plt.refcount++;
2732 }
2733
2734 /* If we are creating a shared library and this is not a local
2735 symbol, we need to copy the reloc into the shared library.
2736 However when linking with -Bsymbolic and this is a global
2737 symbol which is defined in an object we are including in the
2738 link (i.e., DEF_REGULAR is set), then we can resolve the
2739 reloc directly. At this point we have not seen all the input
2740 files, so it is possible that DEF_REGULAR is not set now but
2741 will be set later (it is never cleared). In case of a weak
2742 definition, DEF_REGULAR may be cleared later by a strong
2743 definition in a shared library. We account for that
2744 possibility below by storing information in the relocs_copied
2745 field of the hash table entry. A similar situation occurs
2746 when creating shared libraries and symbol visibility changes
2747 render the symbol local. */
2748
2749 /* No need to do anything if we're not creating a shared object. */
2750 if (! info->shared)
2751 break;
2752
2753 /* We don't need to handle relocs into sections not going into
2754 the "real" output. */
2755 if ((sec->flags & SEC_ALLOC) == 0)
2756 break;
2757
2758 /* We can only eliminate PC-relative relocs. */
2759 if (r_type == R_CRIS_8_PCREL
2760 || r_type == R_CRIS_16_PCREL
2761 || r_type == R_CRIS_32_PCREL)
2762 {
2763 /* If the symbol is local, then we can eliminate the reloc. */
2764 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2765 break;
2766
2767 /* If this is with -Bsymbolic and the symbol isn't weak, and
2768 is defined by an ordinary object (the ones we include in
2769 this shared library) then we can also eliminate the
2770 reloc. See comment above for more eliminable cases which
2771 we can't identify at this time. */
2772 if (info->symbolic
2773 && h->root.type != bfd_link_hash_defweak
2774 && h->def_regular)
2775 break;
2776
2777 if ((sec->flags & SEC_READONLY) != 0)
2778 {
2779 /* FIXME: How do we make this optionally a warning only? */
2780 (*_bfd_error_handler)
2781 (_("%B, section %A:\n relocation %s should not be used"
2782 " in a shared object; recompile with -fPIC"),
2783 abfd,
2784 sec,
2785 cris_elf_howto_table[r_type].name);
2786 }
2787 }
2788
2789 /* We create a reloc section in dynobj and make room for this
2790 reloc. */
2791 if (sreloc == NULL)
2792 {
2793 const char *name;
2794
2795 name = (bfd_elf_string_from_elf_section
2796 (abfd,
2797 elf_elfheader (abfd)->e_shstrndx,
2798 elf_section_data (sec)->rel_hdr.sh_name));
2799 if (name == NULL)
2800 return FALSE;
2801
2802 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2803 && strcmp (bfd_get_section_name (abfd, sec),
2804 name + 5) == 0);
2805
2806 sreloc = bfd_get_section_by_name (dynobj, name);
2807 if (sreloc == NULL)
2808 {
2809 sreloc = bfd_make_section_with_flags (dynobj, name,
2810 (SEC_ALLOC
2811 | SEC_LOAD
2812 | SEC_HAS_CONTENTS
2813 | SEC_IN_MEMORY
2814 | SEC_LINKER_CREATED
2815 | SEC_READONLY));
2816 if (sreloc == NULL
2817 || !bfd_set_section_alignment (dynobj, sreloc, 2))
2818 return FALSE;
2819 }
2820 if (sec->flags & SEC_READONLY)
2821 info->flags |= DF_TEXTREL;
2822 }
2823
2824 sreloc->size += sizeof (Elf32_External_Rela);
2825
2826 /* If we are linking with -Bsymbolic, we count the number of PC
2827 relative relocations we have entered for this symbol, so that
2828 we can discard them again if the symbol is later defined by a
2829 regular object. We know that h is really a pointer to an
2830 elf_cris_link_hash_entry. */
2831 if ((r_type == R_CRIS_8_PCREL
2832 || r_type == R_CRIS_16_PCREL
2833 || r_type == R_CRIS_32_PCREL)
2834 && info->symbolic)
2835 {
2836 struct elf_cris_link_hash_entry *eh;
2837 struct elf_cris_pcrel_relocs_copied *p;
2838
2839 eh = (struct elf_cris_link_hash_entry *) h;
2840
2841 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2842 if (p->section == sreloc)
2843 break;
2844
2845 if (p == NULL)
2846 {
2847 p = ((struct elf_cris_pcrel_relocs_copied *)
2848 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
2849 if (p == NULL)
2850 return FALSE;
2851 p->next = eh->pcrel_relocs_copied;
2852 eh->pcrel_relocs_copied = p;
2853 p->section = sreloc;
2854 p->count = 0;
2855 }
2856
2857 ++p->count;
2858 }
2859 break;
2860
2861 /* This relocation describes the C++ object vtable hierarchy.
2862 Reconstruct it for later use during GC. */
2863 case R_CRIS_GNU_VTINHERIT:
2864 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2865 return FALSE;
2866 break;
2867
2868 /* This relocation describes which C++ vtable entries are actually
2869 used. Record for later use during GC. */
2870 case R_CRIS_GNU_VTENTRY:
2871 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2872 return FALSE;
2873 break;
2874
2875 default:
2876 /* Other relocs do not appear here. */
2877 bfd_set_error (bfd_error_bad_value);
2878 return FALSE;
2879 }
2880 }
2881
2882 return TRUE;
2883 }
2884
2885 /* Set the sizes of the dynamic sections. */
2886
2887 static bfd_boolean
2888 elf_cris_size_dynamic_sections (output_bfd, info)
2889 bfd *output_bfd ATTRIBUTE_UNUSED;
2890 struct bfd_link_info *info;
2891 {
2892 bfd *dynobj;
2893 asection *s;
2894 bfd_boolean plt;
2895 bfd_boolean relocs;
2896
2897 dynobj = elf_hash_table (info)->dynobj;
2898 BFD_ASSERT (dynobj != NULL);
2899
2900 if (elf_hash_table (info)->dynamic_sections_created)
2901 {
2902 /* Set the contents of the .interp section to the interpreter. */
2903 if (info->executable)
2904 {
2905 s = bfd_get_section_by_name (dynobj, ".interp");
2906 BFD_ASSERT (s != NULL);
2907 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2908 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2909 }
2910 }
2911 else
2912 {
2913 /* Adjust all expected GOTPLT uses to use a GOT entry instead. */
2914 elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2915 elf_cris_adjust_gotplt_to_got,
2916 (PTR) info);
2917
2918 /* We may have created entries in the .rela.got section.
2919 However, if we are not creating the dynamic sections, we will
2920 not actually use these entries. Reset the size of .rela.got,
2921 which will cause it to get stripped from the output file
2922 below. */
2923 s = bfd_get_section_by_name (dynobj, ".rela.got");
2924 if (s != NULL)
2925 s->size = 0;
2926 }
2927
2928 /* If this is a -Bsymbolic shared link, then we need to discard all PC
2929 relative relocs against symbols defined in a regular object. We
2930 allocated space for them in the check_relocs routine, but we will not
2931 fill them in in the relocate_section routine. We also discard space
2932 for relocs that have become for local symbols due to symbol
2933 visibility changes. For programs, we discard space for relocs for
2934 symbols not referenced by any dynamic object. */
2935 if (info->shared)
2936 elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2937 elf_cris_discard_excess_dso_dynamics,
2938 (PTR) info);
2939 else
2940 elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2941 elf_cris_discard_excess_program_dynamics,
2942 (PTR) info);
2943
2944 /* The check_relocs and adjust_dynamic_symbol entry points have
2945 determined the sizes of the various dynamic sections. Allocate
2946 memory for them. */
2947 plt = FALSE;
2948 relocs = FALSE;
2949 for (s = dynobj->sections; s != NULL; s = s->next)
2950 {
2951 const char *name;
2952
2953 if ((s->flags & SEC_LINKER_CREATED) == 0)
2954 continue;
2955
2956 /* It's OK to base decisions on the section name, because none
2957 of the dynobj section names depend upon the input files. */
2958 name = bfd_get_section_name (dynobj, s);
2959
2960 if (strcmp (name, ".plt") == 0)
2961 {
2962 /* Remember whether there is a PLT. */
2963 plt = s->size != 0;
2964 }
2965 else if (strncmp (name, ".rela", 5) == 0)
2966 {
2967 if (s->size != 0)
2968 {
2969 /* Remember whether there are any reloc sections other
2970 than .rela.plt. */
2971 if (strcmp (name, ".rela.plt") != 0)
2972 relocs = TRUE;
2973
2974 /* We use the reloc_count field as a counter if we need
2975 to copy relocs into the output file. */
2976 s->reloc_count = 0;
2977 }
2978 }
2979 else if (strncmp (name, ".got", 4) != 0
2980 && strcmp (name, ".dynbss") != 0)
2981 {
2982 /* It's not one of our sections, so don't allocate space. */
2983 continue;
2984 }
2985
2986 if (s->size == 0)
2987 {
2988 /* If we don't need this section, strip it from the
2989 output file. This is mostly to handle .rela.bss and
2990 .rela.plt. We must create both sections in
2991 create_dynamic_sections, because they must be created
2992 before the linker maps input sections to output
2993 sections. The linker does that before
2994 adjust_dynamic_symbol is called, and it is that
2995 function which decides whether anything needs to go
2996 into these sections. */
2997 s->flags |= SEC_EXCLUDE;
2998 continue;
2999 }
3000
3001 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3002 continue;
3003
3004 /* Allocate memory for the section contents. We use bfd_zalloc here
3005 in case unused entries are not reclaimed before the section's
3006 contents are written out. This should not happen, but this way
3007 if it does, we will not write out garbage. For reloc sections,
3008 this will make entries have the type R_CRIS_NONE. */
3009 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3010 if (s->contents == NULL)
3011 return FALSE;
3012 }
3013
3014 if (elf_hash_table (info)->dynamic_sections_created)
3015 {
3016 /* Add some entries to the .dynamic section. We fill in the
3017 values later, in elf_cris_finish_dynamic_sections, but we
3018 must add the entries now so that we get the correct size for
3019 the .dynamic section. The DT_DEBUG entry is filled in by the
3020 dynamic linker and used by the debugger. */
3021 #define add_dynamic_entry(TAG, VAL) \
3022 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3023
3024 if (!info->shared)
3025 {
3026 if (!add_dynamic_entry (DT_DEBUG, 0))
3027 return FALSE;
3028 }
3029
3030 if (plt)
3031 {
3032 if (!add_dynamic_entry (DT_PLTGOT, 0)
3033 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3034 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3035 || !add_dynamic_entry (DT_JMPREL, 0))
3036 return FALSE;
3037 }
3038
3039 if (relocs)
3040 {
3041 if (!add_dynamic_entry (DT_RELA, 0)
3042 || !add_dynamic_entry (DT_RELASZ, 0)
3043 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3044 return FALSE;
3045 }
3046
3047 if ((info->flags & DF_TEXTREL) != 0)
3048 {
3049 if (!add_dynamic_entry (DT_TEXTREL, 0))
3050 return FALSE;
3051 info->flags |= DF_TEXTREL;
3052 }
3053 }
3054 #undef add_dynamic_entry
3055
3056 return TRUE;
3057 }
3058
3059 /* This function is called via elf_cris_link_hash_traverse if we are
3060 creating a shared object. In the -Bsymbolic case, it discards the
3061 space allocated to copy PC relative relocs against symbols which
3062 are defined in regular objects. For the normal non-symbolic case,
3063 we also discard space for relocs that have become local due to
3064 symbol visibility changes. We allocated space for them in the
3065 check_relocs routine, but we won't fill them in in the
3066 relocate_section routine. */
3067
3068 static bfd_boolean
3069 elf_cris_discard_excess_dso_dynamics (h, inf)
3070 struct elf_cris_link_hash_entry *h;
3071 PTR inf;
3072 {
3073 struct elf_cris_pcrel_relocs_copied *s;
3074 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3075
3076 if (h->root.root.type == bfd_link_hash_warning)
3077 h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
3078
3079 /* If a symbol has been forced local or we have found a regular
3080 definition for the symbolic link case, then we won't be needing
3081 any relocs. */
3082 if (h->root.def_regular
3083 && (h->root.forced_local
3084 || info->symbolic))
3085 {
3086 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3087 s->section->size -= s->count * sizeof (Elf32_External_Rela);
3088 }
3089
3090 return TRUE;
3091 }
3092
3093 /* This function is called via elf_cris_link_hash_traverse if we are *not*
3094 creating a shared object. We discard space for relocs for symbols put
3095 in the .got, but which we found we do not have to resolve at run-time. */
3096
3097 static bfd_boolean
3098 elf_cris_discard_excess_program_dynamics (h, inf)
3099 struct elf_cris_link_hash_entry *h;
3100 PTR inf;
3101 {
3102 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3103
3104 if (h->root.root.type == bfd_link_hash_warning)
3105 h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
3106
3107 /* If we're not creating a shared library and have a symbol which is
3108 referred to by .got references, but the symbol is defined locally,
3109 (or rather, not defined by a DSO) then lose the reloc for the .got
3110 (don't allocate room for it). Likewise for relocs for something
3111 for which we create a PLT. */
3112 if (!h->root.def_dynamic
3113 || h->root.plt.refcount > 0)
3114 {
3115 if (h->root.got.refcount > 0
3116 /* The size of this section is only valid and in sync with the
3117 various reference counts if we do dynamic; don't decrement it
3118 otherwise. */
3119 && elf_hash_table (info)->dynamic_sections_created)
3120 {
3121 bfd *dynobj = elf_hash_table (info)->dynobj;
3122 asection *srelgot;
3123
3124 BFD_ASSERT (dynobj != NULL);
3125
3126 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3127
3128 BFD_ASSERT (srelgot != NULL);
3129
3130 srelgot->size -= sizeof (Elf32_External_Rela);
3131 }
3132
3133 /* If the locally-defined symbol isn't used by a DSO, then we don't
3134 have to export it as a dynamic symbol. This was already done for
3135 functions; doing this for all symbols would presumably not
3136 introduce new problems. Of course we don't do this if we're
3137 exporting all dynamic symbols. */
3138 if (! info->export_dynamic
3139 && h->root.dynindx != -1
3140 && !h->root.def_dynamic
3141 && !h->root.ref_dynamic)
3142 {
3143 h->root.dynindx = -1;
3144 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
3145 h->root.dynstr_index);
3146 }
3147 }
3148
3149 return TRUE;
3150 }
3151
3152 /* Reject a file depending on presence and expectation of prefixed
3153 underscores on symbols. */
3154
3155 static bfd_boolean
3156 cris_elf_object_p (abfd)
3157 bfd *abfd;
3158 {
3159 if (! cris_elf_set_mach_from_flags (abfd, elf_elfheader (abfd)->e_flags))
3160 return FALSE;
3161
3162 if ((elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE))
3163 return (bfd_get_symbol_leading_char (abfd) == '_');
3164 else
3165 return (bfd_get_symbol_leading_char (abfd) == 0);
3166 }
3167
3168 /* Mark presence or absence of leading underscore. Set machine type
3169 flags from mach type. */
3170
3171 static void
3172 cris_elf_final_write_processing (abfd, linker)
3173 bfd *abfd;
3174 bfd_boolean linker ATTRIBUTE_UNUSED;
3175 {
3176 unsigned long e_flags = elf_elfheader (abfd)->e_flags;
3177
3178 e_flags &= ~EF_CRIS_UNDERSCORE;
3179 if (bfd_get_symbol_leading_char (abfd) == '_')
3180 e_flags |= EF_CRIS_UNDERSCORE;
3181
3182 switch (bfd_get_mach (abfd))
3183 {
3184 case bfd_mach_cris_v0_v10:
3185 e_flags |= EF_CRIS_VARIANT_ANY_V0_V10;
3186 break;
3187
3188 case bfd_mach_cris_v10_v32:
3189 e_flags |= EF_CRIS_VARIANT_COMMON_V10_V32;
3190 break;
3191
3192 case bfd_mach_cris_v32:
3193 e_flags |= EF_CRIS_VARIANT_V32;
3194 break;
3195
3196 default:
3197 _bfd_abort (__FILE__, __LINE__,
3198 _("Unexpected machine number"));
3199 }
3200
3201 elf_elfheader (abfd)->e_flags = e_flags;
3202 }
3203
3204 /* Set the mach type from e_flags value. */
3205
3206 static bfd_boolean
3207 cris_elf_set_mach_from_flags (abfd, flags)
3208 bfd *abfd;
3209 unsigned long flags;
3210 {
3211 switch (flags & EF_CRIS_VARIANT_MASK)
3212 {
3213 case EF_CRIS_VARIANT_ANY_V0_V10:
3214 bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v0_v10);
3215 break;
3216
3217 case EF_CRIS_VARIANT_V32:
3218 bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v32);
3219 break;
3220
3221 case EF_CRIS_VARIANT_COMMON_V10_V32:
3222 bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v10_v32);
3223 break;
3224
3225 default:
3226 /* Since we don't recognize them, we obviously can't support them
3227 with this code; we'd have to require that all future handling
3228 would be optional. */
3229 bfd_set_error (bfd_error_wrong_format);
3230 return FALSE;
3231 }
3232
3233 return TRUE;
3234 }
3235
3236 /* Display the flags field. */
3237
3238 static bfd_boolean
3239 cris_elf_print_private_bfd_data (abfd, ptr)
3240 bfd *abfd;
3241 PTR ptr;
3242 {
3243 FILE *file = (FILE *) ptr;
3244
3245 BFD_ASSERT (abfd != NULL && ptr != NULL);
3246
3247 _bfd_elf_print_private_bfd_data (abfd, ptr);
3248
3249 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
3250
3251 if (elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE)
3252 fprintf (file, _(" [symbols have a _ prefix]"));
3253 if ((elf_elfheader (abfd)->e_flags & EF_CRIS_VARIANT_MASK)
3254 == EF_CRIS_VARIANT_COMMON_V10_V32)
3255 fprintf (file, _(" [v10 and v32]"));
3256 if ((elf_elfheader (abfd)->e_flags & EF_CRIS_VARIANT_MASK)
3257 == EF_CRIS_VARIANT_V32)
3258 fprintf (file, _(" [v32]"));
3259
3260 fputc ('\n', file);
3261 return TRUE;
3262 }
3263
3264 /* Don't mix files with and without a leading underscore. */
3265
3266 static bfd_boolean
3267 cris_elf_merge_private_bfd_data (ibfd, obfd)
3268 bfd *ibfd;
3269 bfd *obfd;
3270 {
3271 int imach, omach;
3272
3273 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
3274 return FALSE;
3275
3276 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3277 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3278 return TRUE;
3279
3280 imach = bfd_get_mach (ibfd);
3281
3282 if (! elf_flags_init (obfd))
3283 {
3284 /* This happens when ld starts out with a 'blank' output file. */
3285 elf_flags_init (obfd) = TRUE;
3286
3287 /* We ignore the linker-set mach, and instead set it according to
3288 the first input file. This would also happen if we could
3289 somehow filter out the OUTPUT_ARCH () setting from elf.sc.
3290 This allows us to keep the same linker config across
3291 cris(v0..v10) and crisv32. The drawback is that we can't force
3292 the output type, which might be a sane thing to do for a
3293 v10+v32 compatibility object. */
3294 if (! bfd_set_arch_mach (obfd, bfd_arch_cris, imach))
3295 return FALSE;
3296 }
3297
3298 if (bfd_get_symbol_leading_char (ibfd)
3299 != bfd_get_symbol_leading_char (obfd))
3300 {
3301 (*_bfd_error_handler)
3302 (bfd_get_symbol_leading_char (ibfd) == '_'
3303 ? _("%B: uses _-prefixed symbols, but writing file with non-prefixed symbols")
3304 : _("%B: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
3305 ibfd);
3306 bfd_set_error (bfd_error_bad_value);
3307 return FALSE;
3308 }
3309
3310 omach = bfd_get_mach (obfd);
3311
3312 if (imach != omach)
3313 {
3314 /* We can get an incompatible combination only if either is
3315 bfd_mach_cris_v32, and the other one isn't compatible. */
3316 if ((imach == bfd_mach_cris_v32
3317 && omach != bfd_mach_cris_v10_v32)
3318 || (omach == bfd_mach_cris_v32
3319 && imach != bfd_mach_cris_v10_v32))
3320 {
3321 (*_bfd_error_handler)
3322 ((imach == bfd_mach_cris_v32)
3323 ? _("%B contains CRIS v32 code, incompatible"
3324 " with previous objects")
3325 : _("%B contains non-CRIS-v32 code, incompatible"
3326 " with previous objects"),
3327 ibfd);
3328 bfd_set_error (bfd_error_bad_value);
3329 return FALSE;
3330 }
3331
3332 /* We don't have to check the case where the input is compatible
3333 with v10 and v32, because the output is already known to be set
3334 to the other (compatible) mach. */
3335 if (omach == bfd_mach_cris_v10_v32
3336 && ! bfd_set_arch_mach (obfd, bfd_arch_cris, imach))
3337 return FALSE;
3338 }
3339
3340 return TRUE;
3341 }
3342
3343 /* Do side-effects of e_flags copying to obfd. */
3344
3345 static bfd_boolean
3346 cris_elf_copy_private_bfd_data (ibfd, obfd)
3347 bfd *ibfd;
3348 bfd *obfd;
3349 {
3350 /* Call the base function. */
3351 if (!_bfd_elf_copy_private_bfd_data (ibfd, obfd))
3352 return FALSE;
3353
3354 /* If output is big-endian for some obscure reason, stop here. */
3355 if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE)
3356 return FALSE;
3357
3358 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3359 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3360 return TRUE;
3361
3362 /* Do what we really came here for. */
3363 return bfd_set_arch_mach (obfd, bfd_arch_cris, bfd_get_mach (ibfd));
3364 }
3365
3366 static enum elf_reloc_type_class
3367 elf_cris_reloc_type_class (rela)
3368 const Elf_Internal_Rela *rela;
3369 {
3370 switch ((int) ELF32_R_TYPE (rela->r_info))
3371 {
3372 case R_CRIS_RELATIVE:
3373 return reloc_class_relative;
3374 case R_CRIS_JUMP_SLOT:
3375 return reloc_class_plt;
3376 case R_CRIS_COPY:
3377 return reloc_class_copy;
3378 default:
3379 return reloc_class_normal;
3380 }
3381 }
3382 \f
3383 #define ELF_ARCH bfd_arch_cris
3384 #define ELF_MACHINE_CODE EM_CRIS
3385 #define ELF_MAXPAGESIZE 0x2000
3386
3387 #define TARGET_LITTLE_SYM bfd_elf32_cris_vec
3388 #define TARGET_LITTLE_NAME "elf32-cris"
3389 #define elf_symbol_leading_char 0
3390
3391 #define elf_info_to_howto_rel NULL
3392 #define elf_info_to_howto cris_info_to_howto_rela
3393 #define elf_backend_relocate_section cris_elf_relocate_section
3394 #define elf_backend_gc_mark_hook cris_elf_gc_mark_hook
3395 #define elf_backend_gc_sweep_hook cris_elf_gc_sweep_hook
3396 #define elf_backend_check_relocs cris_elf_check_relocs
3397 #define elf_backend_grok_prstatus cris_elf_grok_prstatus
3398 #define elf_backend_grok_psinfo cris_elf_grok_psinfo
3399
3400 #define elf_backend_can_gc_sections 1
3401 #define elf_backend_can_refcount 1
3402
3403 #define elf_backend_object_p cris_elf_object_p
3404 #define elf_backend_final_write_processing \
3405 cris_elf_final_write_processing
3406 #define bfd_elf32_bfd_print_private_bfd_data \
3407 cris_elf_print_private_bfd_data
3408 #define bfd_elf32_bfd_merge_private_bfd_data \
3409 cris_elf_merge_private_bfd_data
3410 #define bfd_elf32_bfd_copy_private_bfd_data \
3411 cris_elf_copy_private_bfd_data
3412
3413 #define bfd_elf32_bfd_reloc_type_lookup cris_reloc_type_lookup
3414
3415 #define bfd_elf32_bfd_link_hash_table_create \
3416 elf_cris_link_hash_table_create
3417 #define elf_backend_adjust_dynamic_symbol \
3418 elf_cris_adjust_dynamic_symbol
3419 #define elf_backend_size_dynamic_sections \
3420 elf_cris_size_dynamic_sections
3421 #define elf_backend_finish_dynamic_symbol \
3422 elf_cris_finish_dynamic_symbol
3423 #define elf_backend_finish_dynamic_sections \
3424 elf_cris_finish_dynamic_sections
3425 #define elf_backend_create_dynamic_sections \
3426 _bfd_elf_create_dynamic_sections
3427 #define bfd_elf32_bfd_final_link \
3428 bfd_elf_gc_common_final_link
3429 #define elf_backend_hide_symbol elf_cris_hide_symbol
3430 #define elf_backend_reloc_type_class elf_cris_reloc_type_class
3431
3432 #define elf_backend_want_got_plt 1
3433 #define elf_backend_plt_readonly 1
3434 #define elf_backend_want_plt_sym 0
3435 #define elf_backend_got_header_size 12
3436
3437 /* Later, we my want to optimize RELA entries into REL entries for dynamic
3438 linking and libraries (if it's a win of any significance). Until then,
3439 take the easy route. */
3440 #define elf_backend_may_use_rel_p 0
3441 #define elf_backend_may_use_rela_p 1
3442 #define elf_backend_rela_normal 1
3443
3444 #include "elf32-target.h"
3445
3446 #define INCLUDED_TARGET_FILE
3447
3448 #undef TARGET_LITTLE_SYM
3449 #undef TARGET_LITTLE_NAME
3450 #undef elf_symbol_leading_char
3451
3452 #define TARGET_LITTLE_SYM bfd_elf32_us_cris_vec
3453 #define TARGET_LITTLE_NAME "elf32-us-cris"
3454 #define elf_symbol_leading_char '_'
3455
3456 #include "elf32-target.h"
git-cvsimport of binutils cvsroot