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