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