projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2002-11-30 Nathanael Nerode <neroden@gcc.gnu.org>
[deliverable/binutils-gdb.git] / bfd / elf32-cris.c
CommitLineData
06c15ad7 1/* CRIS-specific support for 32-bit ELF.
e5094212 2 Copyright 2000, 2001, 2002 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
947216bf 34 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
06c15ad7 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
1e2f5b6e 55 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
06c15ad7
HPN		 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
e5094212 93 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, boolean));
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 */
44aa49bb 183 "R_CRIS_16_PCREL", /* name */
06c15ad7
HPN		 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 */
44aa49bb 198 "R_CRIS_32_PCREL", /* name */
06c15ad7
HPN		 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;
947216bf 461 Elf_Internal_Rela * dst;
06c15ad7
HPN		 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,
cedb70c5 550 0x7e, 0x7e, /* push mof. */
915e5146
HPN		 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
e2d34d7d 713 ret = ((struct elf_cris_link_hash_table *) bfd_malloc (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 {
e2d34d7d 720 free (ret);
915e5146
HPN		 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
f0fe0e16
AM		 802 if (info->relocateable)
803 return true;
804
915e5146
HPN		 805 dynobj = elf_hash_table (info)->dynobj;
806 local_got_offsets = elf_local_got_offsets (input_bfd);
06c15ad7
HPN		 807 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
808 sym_hashes = elf_sym_hashes (input_bfd);
809 relend = relocs + input_section->reloc_count;
810
915e5146
HPN		 811 sgot = NULL;
812 splt = NULL;
813 sreloc = NULL;
814
815 if (dynobj != NULL)
816 {
817 splt = bfd_get_section_by_name (dynobj, ".plt");
818 sgot = bfd_get_section_by_name (dynobj, ".got");
819 }
820
06c15ad7
HPN		 821 for (rel = relocs; rel < relend; rel ++)
822 {
823 reloc_howto_type * howto;
824 unsigned long r_symndx;
825 Elf_Internal_Sym * sym;
826 asection * sec;
827 struct elf_link_hash_entry * h;
828 bfd_vma relocation;
829 bfd_reloc_status_type r;
dc810e39 830 const char * symname = NULL;
06c15ad7 831 int r_type;
a7c10850 832
06c15ad7 833 r_type = ELF32_R_TYPE (rel->r_info);
a7c10850 834
06c15ad7
HPN		 835 if ( r_type == R_CRIS_GNU_VTINHERIT
836 || r_type == R_CRIS_GNU_VTENTRY)
837 continue;
a7c10850 838
06c15ad7 839 /* This is a final link. */
f0fe0e16 840 r_symndx = ELF32_R_SYM (rel->r_info);
915e5146 841 howto = cris_elf_howto_table + r_type;
06c15ad7
HPN		 842 h = NULL;
843 sym = NULL;
844 sec = NULL;
a7c10850 845
06c15ad7
HPN		 846 if (r_symndx < symtab_hdr->sh_info)
847 {
848 sym = local_syms + r_symndx;
849 sec = local_sections [r_symndx];
f8df10f4 850 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
a7c10850 851
dc810e39
AM		 852 symname = (bfd_elf_string_from_elf_section
853 (input_bfd, symtab_hdr->sh_link, sym->st_name));
854 if (symname == NULL)
855 symname = bfd_section_name (input_bfd, sec);
06c15ad7
HPN		 856 }
857 else
858 {
0a4787a0
HPN		 859 /* It seems this can happen with erroneous or unsupported input
860 (mixing a.out and elf in an archive, for example.) */
861 if (sym_hashes == NULL)
862 return false;
863
06c15ad7 864 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
a7c10850 865
06c15ad7
HPN		 866 while (h->root.type == bfd_link_hash_indirect
867 || h->root.type == bfd_link_hash_warning)
868 h = (struct elf_link_hash_entry *) h->root.u.i.link;
869
dc810e39 870 symname = h->root.root.string;
a7c10850 871
06c15ad7
HPN		 872 if (h->root.type == bfd_link_hash_defined
873 || h->root.type == bfd_link_hash_defweak)
874 {
875 sec = h->root.u.def.section;
915e5146
HPN		 876
877 /* Perhaps we should detect the cases that
878 sec->output_section is expected to be NULL like i386 and
879 m68k, but apparently (and according to elfxx-ia64.c) all
880 valid cases are where the symbol is defined in a shared
881 object which we link dynamically against. This includes
882 PLT relocs for which we've created a PLT entry and other
883 relocs for which we're prepared to create dynamic
884 relocations.
885
886 For now, new situations cause us to just err when
887 sec->output_offset is NULL but the object with the symbol
888 is *not* dynamically linked against. Thus this will
889 automatically remind us so we can see if there are other
890 valid cases we need to revisit. */
891 if ((sec->output_section == NULL
892 && (sec->owner->flags & DYNAMIC) != 0)
893
894 /* Here follow the cases where the relocation value must
895 be zero (or when further handling is simplified when
896 zero). I can't claim to understand the various
897 conditions and they weren't described in the files
898 where I copied them from (elf32-m68k.c and
899 elf32-i386.c), but let's mention examples of where
900 they happen. FIXME: Perhaps define and use a
901 dynamic_symbol_p function like ia64.
902
903 - When creating a shared library, we can have an
904 ordinary relocation for a symbol defined in a shared
905 library (perhaps the one we create). We then make
906 the relocation value zero, as the value seen now will
907 be added into the relocation addend in this shared
908 library, but must be handled only at dynamic-link
909 time. FIXME: Not sure this example covers the
910 h->elf_link_hash_flags test, though it's there in
911 other targets. */
912 || (info->shared
913 && ((! info->symbolic && h->dynindx != -1)
914 || (h->elf_link_hash_flags
915 & ELF_LINK_HASH_DEF_REGULAR) == 0)
916 && (input_section->flags & SEC_ALLOC) != 0
917 && (r_type == R_CRIS_8
918 || r_type == R_CRIS_16
919 || r_type == R_CRIS_32
920 || r_type == R_CRIS_8_PCREL
921 || r_type == R_CRIS_16_PCREL
922 || r_type == R_CRIS_32_PCREL)))
923 relocation = 0;
924 else if (sec->output_section != NULL)
925 relocation = (h->root.u.def.value
926 + sec->output_section->vma
927 + sec->output_offset);
928 else
929 {
8f615d07
AM		 930 (*_bfd_error_handler)
931 (_("%s: unresolvable relocation %s against symbol `%s' from %s section"),
932 bfd_archive_filename (input_bfd),
933 cris_elf_howto_table[r_type].name,
934 symname,
935 bfd_get_section_name (input_bfd, input_section));
915e5146
HPN		 936 bfd_set_error (bfd_error_bad_value);
937 return false;
938 }
06c15ad7
HPN		 939 }
940 else if (h->root.type == bfd_link_hash_undefweak)
915e5146 941 relocation = 0;
06c15ad7 942 else if (info->shared
671bae9c 943 && (!info->symbolic || info->allow_shlib_undefined)
915e5146 944 && !info->no_undefined
06c15ad7
HPN		 945 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
946 relocation = 0;
947 else
948 {
915e5146 949 if (!(info->callbacks->undefined_symbol
dc810e39 950 (info, symname, input_bfd,
915e5146
HPN		 951 input_section, rel->r_offset,
952 (!info->shared || info->no_undefined
953 || ELF_ST_VISIBILITY (h->other)))))
06c15ad7 954 return false;
06c15ad7
HPN		 955 relocation = 0;
956 }
957 }
a7c10850 958
915e5146 959 switch (r_type)
06c15ad7 960 {
915e5146
HPN		 961 case R_CRIS_16_GOTPLT:
962 case R_CRIS_32_GOTPLT:
963 /* This is like the case for R_CRIS_32_GOT and R_CRIS_16_GOT,
964 but we require a PLT, and the PLT handling will take care of
965 filling in the PLT-specific GOT entry. For the GOT offset,
966 calculate it as we do when filling it in for the .got.plt
967 section. If we don't have a PLT, punt to GOT handling. */
968 if (h != NULL
969 && ((struct elf_cris_link_hash_entry *) h)->gotplt_offset != 0)
06c15ad7 970 {
915e5146
HPN		 971 asection *sgotplt
972 = bfd_get_section_by_name (dynobj, ".got.plt");
973 bfd_vma got_offset;
a7c10850 974
915e5146
HPN		 975 BFD_ASSERT (h->dynindx != -1);
976 BFD_ASSERT (sgotplt != NULL);
a7c10850 977
915e5146
HPN		 978 got_offset
979 = ((struct elf_cris_link_hash_entry *) h)->gotplt_offset;
06c15ad7 980
915e5146 981 relocation = got_offset;
06c15ad7 982 break;
915e5146 983 }
06c15ad7 984
4d96d128 985 /* We didn't make a PLT entry for this symbol. Maybe everything is
915e5146
HPN		 986 folded into the GOT. Other than folding, this happens when
987 statically linking PIC code, or when using -Bsymbolic. Check
988 that we instead have a GOT entry as done for us by
989 elf_cris_adjust_dynamic_symbol, and drop through into the
990 ordinary GOT cases. */
991 if (h != NULL && h->got.offset == (bfd_vma) -1)
992 {
993 (*_bfd_error_handler)
994 (_("%s: No PLT nor GOT for relocation %s against symbol `%s' from %s section"),
8f615d07 995 bfd_archive_filename (input_bfd),
915e5146 996 cris_elf_howto_table[r_type].name,
dc810e39 997 symname[0] != '\0' ? symname : _("[whose name is lost]"),
915e5146
HPN		 998 bfd_get_section_name (input_bfd, input_section));
999
1000 /* FIXME: Perhaps blaming input is not the right thing to
1001 do; this is probably an internal error. But it is true
1002 that we didn't like that particular input. */
1003 bfd_set_error (bfd_error_bad_value);
1004 return false;
1005 }
1006 /* Fall through. */
1007
1008 /* The size of the actual relocation is not used here; we only
1009 fill in the GOT table here. */
1010 case R_CRIS_16_GOT:
1011 case R_CRIS_32_GOT:
1012 {
1013 bfd_vma off;
1014
1015 /* Note that despite using RELA relocations, the .got contents
1016 is always filled in with the link-relative relocation
1017 value; the addend. */
1018
1019 if (h != NULL)
1020 {
1021 off = h->got.offset;
1022 BFD_ASSERT (off != (bfd_vma) -1);
1023
1024 if (!elf_hash_table (info)->dynamic_sections_created
205cfeb0
HPN		 1025 || (! info->shared
1026 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
915e5146
HPN		 1027 || (info->shared
1028 && (info->symbolic || h->dynindx == -1)
1029 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1030 {
4d96d128 1031 /* This wasn't checked above for ! info->shared, but
6849c52f
HPN		 1032 must hold there if we get here; the symbol must be
1033 defined in the regular program, or be undefweak. */
1034 BFD_ASSERT (!elf_hash_table (info)->dynamic_sections_created
1035 || info->shared
4d96d128 1036 || (h->elf_link_hash_flags
6849c52f
HPN		 1037 & ELF_LINK_HASH_DEF_REGULAR) != 0
1038 || h->root.type == bfd_link_hash_undefweak);
4d96d128 1039
915e5146 1040 /* This is actually a static link, or it is a
6849c52f
HPN		 1041 -Bsymbolic link and the symbol is defined locally,
1042 or is undefweak, or the symbol was forced to be
1043 local because of a version file, or we're not
1044 creating a dynamic object. We must initialize this
1045 entry in the global offset table. Since the offset
1046 must always be a multiple of 4, we use the least
1047 significant bit to record whether we have
1048 initialized it already.
1049
1050 If this GOT entry should be runtime-initialized, we
1051 will create a .rela.got relocation entry to
1052 initialize the value. This is done in the
1053 finish_dynamic_symbol routine. */
915e5146
HPN		 1054 if ((off & 1) != 0)
1055 off &= ~1;
1056 else
1057 {
1058 bfd_put_32 (output_bfd, relocation,
1059 sgot->contents + off);
1060 h->got.offset |= 1;
1061 }
1062 }
1063 }
1064 else
1065 {
1066 BFD_ASSERT (local_got_offsets != NULL
1067 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1068
1069 off = local_got_offsets[r_symndx];
1070
1071 /* The offset must always be a multiple of 4. We use
1072 the least significant bit to record whether we have
1073 already generated the necessary reloc. */
1074 if ((off & 1) != 0)
1075 off &= ~1;
1076 else
1077 {
1078 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1079
1080 if (info->shared)
1081 {
947216bf 1082 asection *s;
915e5146 1083 Elf_Internal_Rela outrel;
947216bf 1084 bfd_byte *loc;
915e5146 1085
947216bf
AM		 1086 s = bfd_get_section_by_name (dynobj, ".rela.got");
1087 BFD_ASSERT (s != NULL);
915e5146
HPN		 1088
1089 outrel.r_offset = (sgot->output_section->vma
1090 + sgot->output_offset
1091 + off);
1092 outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1093 outrel.r_addend = relocation;
947216bf
AM		 1094 loc = s->contents;
1095 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1096 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
915e5146
HPN		 1097 }
1098
1099 local_got_offsets[r_symndx] |= 1;
1100 }
1101 }
1102
1103 relocation = sgot->output_offset + off;
1104 if (rel->r_addend != 0)
1105 {
1106 /* We can't do anything for a relocation which is against
1107 a symbol *plus offset*. GOT holds relocations for
1108 symbols. Make this an error; the compiler isn't
1109 allowed to pass us these kinds of things. */
1110 if (h == NULL)
1111 (*_bfd_error_handler)
1112 (_("%s: relocation %s with non-zero addend %d against local symbol from %s section"),
8f615d07 1113 bfd_archive_filename (input_bfd),
915e5146
HPN		 1114 cris_elf_howto_table[r_type].name,
1115 rel->r_addend,
1116 bfd_get_section_name (input_bfd, input_section));
1117 else
1118 (*_bfd_error_handler)
1119 (_("%s: relocation %s with non-zero addend %d against symbol `%s' from %s section"),
8f615d07 1120 bfd_archive_filename (input_bfd),
915e5146
HPN		 1121 cris_elf_howto_table[r_type].name,
1122 rel->r_addend,
dc810e39 1123 symname[0] != '\0' ? symname : _("[whose name is lost]"),
915e5146
HPN		 1124 bfd_get_section_name (input_bfd, input_section));
1125
1126 bfd_set_error (bfd_error_bad_value);
1127 return false;
1128 }
1129 }
1130 break;
06c15ad7 1131
915e5146
HPN		 1132 case R_CRIS_32_GOTREL:
1133 /* This relocation must only be performed against local symbols. */
0a4787a0 1134 if (h != NULL && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
915e5146
HPN		 1135 {
1136 (*_bfd_error_handler)
1137 (_("%s: relocation %s is not allowed for global symbol: `%s' from %s section"),
8f615d07 1138 bfd_archive_filename (input_bfd),
915e5146 1139 cris_elf_howto_table[r_type].name,
dc810e39 1140 symname,
915e5146
HPN		 1141 bfd_get_section_name (input_bfd, input_section));
1142 bfd_set_error (bfd_error_bad_value);
1143 return false;
06c15ad7
HPN		 1144 }
1145
58255df3
HPN		 1146 /* This can happen if we get a link error with the input ELF
1147 variant mismatching the output variant. Emit an error so
1148 it's noticed if it happens elsewhere. */
1149 if (sgot == NULL)
1150 {
1151 (*_bfd_error_handler)
1152 (_("%s: relocation %s in section %s with no GOT created"),
1153 bfd_archive_filename (input_bfd),
1154 cris_elf_howto_table[r_type].name,
1155 bfd_get_section_name (input_bfd, input_section));
1156 bfd_set_error (bfd_error_bad_value);
1157 return false;
1158 }
1159
915e5146
HPN		 1160 /* This relocation is like a PC-relative one, except the
1161 reference point is the location of GOT. Note that
1162 sgot->output_offset is not involved in this calculation. We
1163 always want the start of entire .got section, not the
1164 position after the reserved header. */
1165 relocation -= sgot->output_section->vma;
1166 break;
06c15ad7 1167
915e5146
HPN		 1168 case R_CRIS_32_PLT_PCREL:
1169 /* Relocation is to the entry for this symbol in the
1170 procedure linkage table. */
06c15ad7 1171
915e5146
HPN		 1172 /* Resolve a PLT_PCREL reloc against a local symbol directly,
1173 without using the procedure linkage table. */
0a4787a0 1174 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
915e5146
HPN		 1175 break;
1176
1177 if (h->plt.offset == (bfd_vma) -1
1178 || splt == NULL)
1179 {
1180 /* We didn't make a PLT entry for this symbol. This
1181 happens when statically linking PIC code, or when
1182 using -Bsymbolic. */
1183 break;
1184 }
1185
1186 relocation = (splt->output_section->vma
1187 + splt->output_offset
1188 + h->plt.offset);
1189 break;
1190
1191 case R_CRIS_32_PLT_GOTREL:
1192 /* Like R_CRIS_32_PLT_PCREL, but the reference point is the
1193 start of the .got section. See also comment at
1194 R_CRIS_32_GOT. */
1195 relocation -= sgot->output_section->vma;
1196
1197 /* Resolve a PLT_GOTREL reloc against a local symbol directly,
1198 without using the procedure linkage table. */
0a4787a0 1199 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
915e5146
HPN		 1200 break;
1201
1202 if (h->plt.offset == (bfd_vma) -1
1203 || splt == NULL)
1204 {
1205 /* We didn't make a PLT entry for this symbol. This
1206 happens when statically linking PIC code, or when
1207 using -Bsymbolic. */
1208 break;
1209 }
1210
1211 relocation = (splt->output_section->vma
1212 + splt->output_offset
1213 + h->plt.offset
1214 - sgot->output_section->vma);
1215 break;
1216
1217 case R_CRIS_8_PCREL:
1218 case R_CRIS_16_PCREL:
1219 case R_CRIS_32_PCREL:
1220 /* If the symbol was local, we need no shlib-specific handling. */
0a4787a0 1221 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
915e5146
HPN		 1222 break;
1223
1224 /* Fall through. */
1225 case R_CRIS_8:
1226 case R_CRIS_16:
1227 case R_CRIS_32:
1228 if (info->shared
ec338859 1229 && r_symndx != 0
915e5146
HPN		 1230 && (input_section->flags & SEC_ALLOC) != 0
1231 && ((r_type != R_CRIS_8_PCREL
1232 && r_type != R_CRIS_16_PCREL
1233 && r_type != R_CRIS_32_PCREL)
1234 || (!info->symbolic
1235 || (h->elf_link_hash_flags
1236 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1237 {
1238 Elf_Internal_Rela outrel;
947216bf 1239 bfd_byte *loc;
915e5146
HPN		 1240 boolean skip, relocate;
1241
1242 /* When generating a shared object, these relocations
1243 are copied into the output file to be resolved at run
1244 time. */
1245
1246 if (sreloc == NULL)
1247 {
1248 const char *name;
1249
1250 name = (bfd_elf_string_from_elf_section
1251 (input_bfd,
1252 elf_elfheader (input_bfd)->e_shstrndx,
1253 elf_section_data (input_section)->rel_hdr.sh_name));
1254 if (name == NULL)
1255 return false;
1256
1257 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1258 && strcmp (bfd_get_section_name (input_bfd,
1259 input_section),
1260 name + 5) == 0);
1261
1262 sreloc = bfd_get_section_by_name (dynobj, name);
1263
1264 /* That section should have been created in
1265 cris_elf_check_relocs, but that function will not be
1266 called for objects which fail in
1267 cris_elf_merge_private_bfd_data. */
1268 if (sreloc == NULL)
1269 {
1270 (*_bfd_error_handler)
1271 (_("%s: Internal inconsistency; no relocation section %s"),
8f615d07 1272 bfd_archive_filename (input_bfd),
915e5146
HPN		 1273 name);
1274
1275 bfd_set_error (bfd_error_bad_value);
1276 return false;
1277 }
1278 }
1279
1280 skip = false;
0bb2d96a 1281 relocate = false;
915e5146 1282
c629eae0
JJ		 1283 outrel.r_offset =
1284 _bfd_elf_section_offset (output_bfd, info, input_section,
1285 rel->r_offset);
1286 if (outrel.r_offset == (bfd_vma) -1)
1287 skip = true;
0bb2d96a
JJ		 1288 else if (outrel.r_offset == (bfd_vma) -2)
1289 skip = true, relocate = true;
915e5146
HPN		 1290 outrel.r_offset += (input_section->output_section->vma
1291 + input_section->output_offset);
1292
1293 if (skip)
0bb2d96a 1294 memset (&outrel, 0, sizeof outrel);
915e5146
HPN		 1295 /* h->dynindx may be -1 if the symbol was marked to
1296 become local. */
1297 else if (h != NULL
1298 && ((! info->symbolic && h->dynindx != -1)
1299 || (h->elf_link_hash_flags
1300 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1301 {
1302 BFD_ASSERT (h->dynindx != -1);
915e5146
HPN		 1303 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1304 outrel.r_addend = relocation + rel->r_addend;
1305 }
1306 else
1307 {
1308 if (r_type == R_CRIS_32)
1309 {
1310 relocate = true;
1311 outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1312 outrel.r_addend = relocation + rel->r_addend;
1313 }
1314 else
1315 {
1316 long indx;
1317
1318 if (h == NULL)
1319 sec = local_sections[r_symndx];
1320 else
1321 {
1322 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1323 || (h->root.type
1324 == bfd_link_hash_defweak));
1325 sec = h->root.u.def.section;
1326 }
1327 if (sec != NULL && bfd_is_abs_section (sec))
1328 indx = 0;
1329 else if (sec == NULL || sec->owner == NULL)
1330 {
1331 bfd_set_error (bfd_error_bad_value);
1332 return false;
1333 }
1334 else
1335 {
1336 asection *osec;
1337
1338 osec = sec->output_section;
1339 indx = elf_section_data (osec)->dynindx;
1340 BFD_ASSERT (indx > 0);
1341 }
1342
915e5146
HPN		 1343 outrel.r_info = ELF32_R_INFO (indx, r_type);
1344 outrel.r_addend = relocation + rel->r_addend;
1345 }
1346 }
1347
947216bf
AM		 1348 loc = sreloc->contents;
1349 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1350 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
915e5146
HPN		 1351
1352 /* This reloc will be computed at runtime, so there's no
1353 need to do anything now, except for R_CRIS_32 relocations
1354 that have been turned into R_CRIS_RELATIVE. */
1355 if (!relocate)
1356 continue;
1357 }
1358
1359 break;
1360 }
1361
1362 r = cris_final_link_relocate (howto, input_bfd, input_section,
1363 contents, rel, relocation);
1364
1365 if (r != bfd_reloc_ok)
1366 {
1367 const char * msg = (const char *) NULL;
1368
1369 switch (r)
1370 {
1371 case bfd_reloc_overflow:
1372 r = info->callbacks->reloc_overflow
dc810e39 1373 (info, symname, howto->name, (bfd_vma) 0,
915e5146
HPN		 1374 input_bfd, input_section, rel->r_offset);
1375 break;
1376
1377 case bfd_reloc_undefined:
1378 r = info->callbacks->undefined_symbol
dc810e39 1379 (info, symname, input_bfd, input_section, rel->r_offset,
915e5146
HPN		 1380 true);
1381 break;
1382
1383 case bfd_reloc_outofrange:
1384 msg = _("internal error: out of range error");
1385 break;
1386
1387 case bfd_reloc_notsupported:
1388 msg = _("internal error: unsupported relocation error");
1389 break;
1390
1391 case bfd_reloc_dangerous:
1392 msg = _("internal error: dangerous relocation");
1393 break;
1394
1395 default:
1396 msg = _("internal error: unknown error");
1397 break;
1398 }
1399
1400 if (msg)
1401 r = info->callbacks->warning
dc810e39 1402 (info, msg, symname, input_bfd, input_section, rel->r_offset);
915e5146
HPN		 1403
1404 if (! r)
1405 return false;
1406 }
1407 }
1408
1409 return true;
1410}
1411\f
1412/* Finish up dynamic symbol handling. We set the contents of various
1413 dynamic sections here. */
1414
1415static boolean
1416elf_cris_finish_dynamic_symbol (output_bfd, info, h, sym)
1417 bfd *output_bfd;
1418 struct bfd_link_info *info;
1419 struct elf_link_hash_entry *h;
1420 Elf_Internal_Sym *sym;
1421{
1422 bfd *dynobj;
1423 int plt_off1 = 2, plt_off2 = 10, plt_off3 = 16;
1424
1425 dynobj = elf_hash_table (info)->dynobj;
1426
1427 if (h->plt.offset != (bfd_vma) -1)
1428 {
1429 asection *splt;
1430 asection *sgotplt;
1431 asection *sgot;
1432 asection *srela;
1433 bfd_vma got_base;
1434
1435 bfd_vma gotplt_offset
1436 = ((struct elf_cris_link_hash_entry *) h)->gotplt_offset;
1437 Elf_Internal_Rela rela;
947216bf 1438 bfd_byte *loc;
915e5146
HPN		 1439 boolean has_gotplt = gotplt_offset != 0;
1440
1441 /* Get the index in the procedure linkage table which
1442 corresponds to this symbol. This is the index of this symbol
1443 in all the symbols for which we are making plt entries. The
1444 first entry in the procedure linkage table is reserved. */
1445 /* We have to count backwards here, and the result is only valid as
1446 an index into .got.plt and its relocations. FIXME: Constants... */
1447 bfd_vma gotplt_index = gotplt_offset/4 - 3;
1448
1449 /* Get the offset into the .got table of the entry that corresponds
1450 to this function. Note that we embed knowledge that "incoming"
1451 .got goes after .got.plt in the output without padding (pointer
1452 aligned). However, that knowledge is present in several other
1453 places too, here and in elflink.h at least. */
1454 bfd_vma got_offset
1455 = (has_gotplt
1456 ? gotplt_offset
1457 : h->got.offset + elf_cris_hash_table(info)->next_gotplt_entry);
1458
1459 /* This symbol has an entry in the procedure linkage table. Set it
1460 up. */
1461
1462 BFD_ASSERT (h->dynindx != -1);
1463
1464 splt = bfd_get_section_by_name (dynobj, ".plt");
1465 sgot = bfd_get_section_by_name (dynobj, ".got");
1466 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1467 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1468 BFD_ASSERT (splt != NULL && sgotplt != NULL
1469 && (! has_gotplt || srela != NULL));
1470
1471 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
1472
1473 /* Fill in the entry in the procedure linkage table. */
1474 if (! info->shared)
1475 {
1476 memcpy (splt->contents + h->plt.offset, elf_cris_plt_entry,
1477 PLT_ENTRY_SIZE);
1478
1479 /* We need to enter the absolute address of the GOT entry here. */
1480 bfd_put_32 (output_bfd, got_base + got_offset,
1481 splt->contents + h->plt.offset + plt_off1);
1482 }
1483 else
1484 {
1485 memcpy (splt->contents + h->plt.offset, elf_cris_pic_plt_entry,
1486 PLT_ENTRY_SIZE);
1487 bfd_put_32 (output_bfd, got_offset,
1488 splt->contents + h->plt.offset + plt_off1);
1489 }
1490
1491 /* Fill in the plt entry and make a relocation, if this is a "real"
1492 PLT entry. */
1493 if (has_gotplt)
1494 {
1495 /* Fill in the offset into the reloc table. */
1496 bfd_put_32 (output_bfd,
1497 gotplt_index * sizeof (Elf32_External_Rela),
1498 splt->contents + h->plt.offset + plt_off2);
1499
1500 /* Fill in the offset to the first PLT entry, where to "jump". */
1501 bfd_put_32 (output_bfd, - (h->plt.offset + plt_off3 + 4),
1502 splt->contents + h->plt.offset + plt_off3);
1503
1504 /* Fill in the entry in the global offset table with the address of
1505 the relocating stub. */
1506 bfd_put_32 (output_bfd,
1507 (splt->output_section->vma
1508 + splt->output_offset
1509 + h->plt.offset
1510 + 8),
1511 sgotplt->contents + got_offset);
1512
1513 /* Fill in the entry in the .rela.plt section. */
1514 rela.r_offset = (sgotplt->output_section->vma
1515 + sgotplt->output_offset
1516 + got_offset);
1517 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_JUMP_SLOT);
1518 rela.r_addend = 0;
947216bf
AM		 1519 loc = srela->contents + gotplt_index * sizeof (Elf32_External_Rela);
1520 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
915e5146
HPN		 1521 }
1522
1523 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1524 {
1525 /* Mark the symbol as undefined, rather than as defined in
1526 the .plt section. Leave the value alone. */
1527 sym->st_shndx = SHN_UNDEF;
1528
1529 /* FIXME: From elf32-sparc.c 2001-02-19 (1.18). I still don't
1530 know whether resetting the value is significant; if it really
1531 is, rather than a quirk or bug in the sparc port, then I
1532 believe we'd see this elsewhere. */
1533 /* If the symbol is weak, we do need to clear the value.
1534 Otherwise, the PLT entry would provide a definition for
1535 the symbol even if the symbol wasn't defined anywhere,
1536 and so the symbol would never be NULL. */
1537 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
1538 == 0)
1539 sym->st_value = 0;
1540 }
1541 }
1542
4d96d128 1543 /* We don't emit .got relocs for symbols that aren't in the
6849c52f
HPN		 1544 dynamic-symbols table for an ordinary program and are either defined
1545 by the program or are undefined weak symbols. */
4d96d128 1546 if (h->got.offset != (bfd_vma) -1
6849c52f
HPN		 1547 && (info->shared
1548 || (h->dynindx != -1
1549 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1550 && h->root.type != bfd_link_hash_undefweak)))
915e5146
HPN		 1551 {
1552 asection *sgot;
1553 asection *srela;
1554 Elf_Internal_Rela rela;
947216bf 1555 bfd_byte *loc;
dc810e39 1556 bfd_byte *where;
915e5146
HPN		 1557
1558 /* This symbol has an entry in the global offset table. Set it up. */
1559
1560 sgot = bfd_get_section_by_name (dynobj, ".got");
1561 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1562 BFD_ASSERT (sgot != NULL && srela != NULL);
1563
1564 rela.r_offset = (sgot->output_section->vma
1565 + sgot->output_offset
dc810e39 1566 + (h->got.offset &~ (bfd_vma) 1));
915e5146
HPN		 1567
1568 /* If this is a static link, or it is a -Bsymbolic link and the
1569 symbol is defined locally or was forced to be local because
1570 of a version file, we just want to emit a RELATIVE reloc.
1571 The entry in the global offset table will already have been
1572 initialized in the relocate_section function. */
dc810e39 1573 where = sgot->contents + (h->got.offset &~ (bfd_vma) 1);
915e5146
HPN		 1574 if (! elf_hash_table (info)->dynamic_sections_created
1575 || (info->shared
1576 && (info->symbolic || h->dynindx == -1)
1577 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1578 {
1579 rela.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
dc810e39 1580 rela.r_addend = bfd_get_signed_32 (output_bfd, where);
915e5146
HPN		 1581 }
1582 else
1583 {
dc810e39 1584 bfd_put_32 (output_bfd, (bfd_vma) 0, where);
915e5146
HPN		 1585 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_GLOB_DAT);
1586 rela.r_addend = 0;
1587 }
1588
947216bf
AM		 1589 loc = srela->contents;
1590 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
1591 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
915e5146
HPN		 1592 }
1593
1594 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1595 {
1596 asection *s;
1597 Elf_Internal_Rela rela;
947216bf 1598 bfd_byte *loc;
915e5146
HPN		 1599
1600 /* This symbol needs a copy reloc. Set it up. */
1601
1602 BFD_ASSERT (h->dynindx != -1
1603 && (h->root.type == bfd_link_hash_defined
1604 || h->root.type == bfd_link_hash_defweak));
1605
1606 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1607 ".rela.bss");
1608 BFD_ASSERT (s != NULL);
1609
1610 rela.r_offset = (h->root.u.def.value
1611 + h->root.u.def.section->output_section->vma
1612 + h->root.u.def.section->output_offset);
1613 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_COPY);
1614 rela.r_addend = 0;
947216bf
AM		 1615 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
1616 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
915e5146
HPN		 1617 }
1618
1619 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1620 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1621 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1622 sym->st_shndx = SHN_ABS;
1623
1624 return true;
1625}
1626\f
1627/* Finish up the dynamic sections. */
1628
1629static boolean
1630elf_cris_finish_dynamic_sections (output_bfd, info)
1631 bfd *output_bfd;
1632 struct bfd_link_info *info;
1633{
1634 bfd *dynobj;
1635 asection *sgot;
1636 asection *sdyn;
1637
1638 dynobj = elf_hash_table (info)->dynobj;
1639
1640 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1641 BFD_ASSERT (sgot != NULL);
1642 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1643
1644 if (elf_hash_table (info)->dynamic_sections_created)
1645 {
1646 asection *splt;
1647 Elf32_External_Dyn *dyncon, *dynconend;
1648
1649 splt = bfd_get_section_by_name (dynobj, ".plt");
1650 BFD_ASSERT (splt != NULL && sdyn != NULL);
1651
1652 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1653 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1654 for (; dyncon < dynconend; dyncon++)
1655 {
1656 Elf_Internal_Dyn dyn;
1657 asection *s;
1658
1659 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1660
1661 switch (dyn.d_tag)
1662 {
1663 default:
1664 break;
1665
1666 case DT_PLTGOT:
1667 s = bfd_get_section_by_name (output_bfd, ".got");
1668 BFD_ASSERT (s != NULL);
1669 dyn.d_un.d_ptr = s->vma;
1670 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1671 break;
1672
1673 case DT_JMPREL:
1674 /* Yes, we *can* have a .plt and no .plt.rela, for instance
1675 if all symbols are found in the .got (not .got.plt). */
1676 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1677 dyn.d_un.d_ptr = s != NULL ? s->vma : 0;
1678 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1679 break;
1680
1681 case DT_PLTRELSZ:
1682 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1683 if (s == NULL)
1684 dyn.d_un.d_val = 0;
1685 else if (s->_cooked_size != 0)
1686 dyn.d_un.d_val = s->_cooked_size;
1687 else
1688 dyn.d_un.d_val = s->_raw_size;
1689 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1690 break;
1691
1692 case DT_RELASZ:
1693 /* The procedure linkage table relocs (DT_JMPREL) should
1694 not be included in the overall relocs (DT_RELA).
1695 Therefore, we override the DT_RELASZ entry here to
1696 make it not include the JMPREL relocs. Since the
1697 linker script arranges for .rela.plt to follow all
1698 other relocation sections, we don't have to worry
1699 about changing the DT_RELA entry. */
1700 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1701 if (s != NULL)
1702 {
1703 if (s->_cooked_size != 0)
1704 dyn.d_un.d_val -= s->_cooked_size;
1705 else
1706 dyn.d_un.d_val -= s->_raw_size;
1707 }
1708 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1709 break;
1710 }
1711 }
1712
1713 /* Fill in the first entry in the procedure linkage table. */
1714 if (splt->_raw_size > 0)
1715 {
1716 if (info->shared)
1717 memcpy (splt->contents, elf_cris_pic_plt0_entry, PLT_ENTRY_SIZE);
1718 else
1719 {
1720 memcpy (splt->contents, elf_cris_plt0_entry, PLT_ENTRY_SIZE);
1721 bfd_put_32 (output_bfd,
1722 sgot->output_section->vma + sgot->output_offset + 4,
1723 splt->contents + 6);
1724 bfd_put_32 (output_bfd,
1725 sgot->output_section->vma + sgot->output_offset + 8,
1726 splt->contents + 14);
1727
1728 elf_section_data (splt->output_section)->this_hdr.sh_entsize
1729 = PLT_ENTRY_SIZE;
1730 }
1731 }
1732 }
1733
1734 /* Fill in the first three entries in the global offset table. */
1735 if (sgot->_raw_size > 0)
1736 {
1737 if (sdyn == NULL)
1738 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1739 else
1740 bfd_put_32 (output_bfd,
1741 sdyn->output_section->vma + sdyn->output_offset,
1742 sgot->contents);
1743 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1744 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1745 }
1746
1747 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1748
1749 return true;
06c15ad7
HPN		 1750}
1751\f
1752/* Return the section that should be marked against GC for a given
1753 relocation. */
1754
1755static asection *
1e2f5b6e
AM		 1756cris_elf_gc_mark_hook (sec, info, rel, h, sym)
1757 asection * sec;
06c15ad7
HPN		 1758 struct bfd_link_info * info ATTRIBUTE_UNUSED;
1759 Elf_Internal_Rela * rel;
1760 struct elf_link_hash_entry * h;
1761 Elf_Internal_Sym * sym;
1762{
1763 if (h != NULL)
1764 {
1765 switch (ELF32_R_TYPE (rel->r_info))
1766 {
1767 case R_CRIS_GNU_VTINHERIT:
1768 case R_CRIS_GNU_VTENTRY:
1769 break;
1770
1771 default:
1772 switch (h->root.type)
1773 {
1774 case bfd_link_hash_defined:
1775 case bfd_link_hash_defweak:
1776 return h->root.u.def.section;
1777
1778 case bfd_link_hash_common:
1779 return h->root.u.c.p->section;
1780
1781 default:
1782 break;
1783 }
1784 }
1785 }
1786 else
1e2f5b6e 1787 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
06c15ad7
HPN		 1788
1789 return NULL;
1790}
1791
1792/* Update the got entry reference counts for the section being removed. */
1793
1794static boolean
1795cris_elf_gc_sweep_hook (abfd, info, sec, relocs)
1796 bfd * abfd ATTRIBUTE_UNUSED;
1797 struct bfd_link_info * info ATTRIBUTE_UNUSED;
1798 asection * sec ATTRIBUTE_UNUSED;
1799 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;
1800{
915e5146
HPN		 1801 Elf_Internal_Shdr *symtab_hdr;
1802 struct elf_link_hash_entry **sym_hashes;
1803 bfd_signed_vma *local_got_refcounts;
1804 const Elf_Internal_Rela *rel, *relend;
1805 unsigned long r_symndx;
1806 struct elf_link_hash_entry *h;
1807 bfd *dynobj;
1808 asection *sgot;
1809 asection *srelgot;
1810
1811 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1812 sym_hashes = elf_sym_hashes (abfd);
1813 local_got_refcounts = elf_local_got_refcounts (abfd);
1814
1815 dynobj = elf_hash_table (info)->dynobj;
1816 if (dynobj == NULL)
1817 return true;
1818
1819 sgot = bfd_get_section_by_name (dynobj, ".got");
1820 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1821
1822 relend = relocs + sec->reloc_count;
1823 for (rel = relocs; rel < relend; rel++)
1824 {
1825 switch (ELF32_R_TYPE (rel->r_info))
1826 {
1827 case R_CRIS_16_GOT:
1828 case R_CRIS_32_GOT:
1829 r_symndx = ELF32_R_SYM (rel->r_info);
1830 if (r_symndx >= symtab_hdr->sh_info)
1831 {
1832 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1833 if (h->got.refcount > 0)
1834 {
1835 --h->got.refcount;
1836 if (h->got.refcount == 0)
1837 {
1838 /* We don't need the .got entry any more. */
1839 sgot->_raw_size -= 4;
1840 srelgot->_raw_size -= sizeof (Elf32_External_Rela);
1841 }
1842 }
1843 break;
1844 }
1845
1846 local_got_reloc:
1847 if (local_got_refcounts != NULL)
1848 {
1849 if (local_got_refcounts[r_symndx] > 0)
1850 {
1851 --local_got_refcounts[r_symndx];
1852 if (local_got_refcounts[r_symndx] == 0)
1853 {
1854 /* We don't need the .got entry any more. */
1855 sgot->_raw_size -= 4;
1856 if (info->shared)
1857 srelgot->_raw_size -= sizeof (Elf32_External_Rela);
1858 }
1859 }
1860 }
1861 break;
1862
1863 case R_CRIS_16_GOTPLT:
1864 case R_CRIS_32_GOTPLT:
1865 /* For local symbols, treat these like GOT relocs. */
1866 r_symndx = ELF32_R_SYM (rel->r_info);
1867 if (r_symndx < symtab_hdr->sh_info)
1868 goto local_got_reloc;
1869
1870 case R_CRIS_32_PLT_GOTREL:
1871 /* FIXME: We don't garbage-collect away the .got section. */
1872 if (local_got_refcounts != NULL)
1873 local_got_refcounts[-1]--;
1874 /* Fall through. */
1875
1876 case R_CRIS_8_PCREL:
1877 case R_CRIS_16_PCREL:
1878 case R_CRIS_32_PCREL:
1879 case R_CRIS_32_PLT_PCREL:
1880 r_symndx = ELF32_R_SYM (rel->r_info);
1881 if (r_symndx >= symtab_hdr->sh_info)
1882 {
1883 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
0a4787a0
HPN		 1884 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1885 && h->plt.refcount > 0)
915e5146
HPN		 1886 --h->plt.refcount;
1887 }
1888 break;
1889
1890 default:
1891 break;
1892 }
1893 }
1894
06c15ad7
HPN		 1895 return true;
1896}
1897
915e5146
HPN		 1898/* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1899 entry but we found we will not create any. Called when we find we will
4d96d128
HPN		 1900 not have any PLT for this symbol, by for example
1901 elf_cris_adjust_dynamic_symbol when we're doing a proper dynamic link,
1902 or elf_cris_size_dynamic_sections if no dynamic sections will be
1903 created (we're only linking static objects). */
915e5146
HPN		 1904
1905static boolean
1906elf_cris_adjust_gotplt_to_got (h, p)
1907 struct elf_cris_link_hash_entry *h;
1908 PTR p;
1909{
1910 struct bfd_link_info *info = (struct bfd_link_info *) p;
1911 bfd *dynobj = elf_hash_table (info)->dynobj;
1912
1913 BFD_ASSERT (dynobj != NULL);
1914
e92d460e
AM		 1915 if (h->root.root.type == bfd_link_hash_warning)
1916 h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
1917
915e5146
HPN		 1918 /* If nobody wanted a GOTPLT with this symbol, we're done. */
1919 if (h->gotplt_refcount <= 0)
1920 return true;
1921
1922 if (h->root.got.refcount > 0)
1923 {
1924 /* There's a GOT entry for this symbol. Just adjust the refcount.
1925 Probably not necessary at this stage, but keeping it accurate
1926 helps avoiding surprises later. */
1927 h->root.got.refcount += h->gotplt_refcount;
1928 h->gotplt_refcount = -1;
1929 }
1930 else
1931 {
4d96d128 1932 /* No GOT entry for this symbol. We need to create one. */
915e5146
HPN		 1933 asection *sgot = bfd_get_section_by_name (dynobj, ".got");
1934 asection *srelgot
1935 = bfd_get_section_by_name (dynobj, ".rela.got");
1936
1937 /* Put an accurate refcount there. */
1938 h->root.got.refcount = h->gotplt_refcount;
1939
1940 h->gotplt_refcount = -1;
1941
44aa49bb
HPN		 1942 /* We always have a .got and a .rela.got section if there were
1943 GOTPLT relocs in input. */
1944 BFD_ASSERT (sgot != NULL && srelgot != NULL);
915e5146
HPN		 1945
1946 /* Allocate space in the .got section. */
1947 sgot->_raw_size += 4;
1948
1949 /* Allocate relocation space. */
1950 srelgot->_raw_size += sizeof (Elf32_External_Rela);
1951 }
1952
1953 return true;
1954}
1955
1956/* Try to fold PLT entries with GOT entries. There are two cases when we
1957 want to do this:
1958
1959 - When all PLT references are GOTPLT references, and there are GOT
1960 references. We don't have to generate a PLT at all.
1961
1962 - When there are both (ordinary) PLT references and GOT references.
1963 We want to make the PLT reference use the ordinary GOT entry rather
1964 than a run-time dynamically resolved GOTPLT entry (since the GOT
1965 entry will have to be resolved at startup anyway).
1966
1967 Though the latter case is handled when room for the PLT is allocated,
1968 not here.
1969
1970 Note that this function is called before symbols are forced local by
1971 version scripts. The differing cases are handled by
1972 elf_cris_hide_symbol. */
1973
1974static boolean
1975elf_cris_try_fold_plt_to_got (h, p)
1976 struct elf_cris_link_hash_entry *h;
1977 PTR p;
1978{
1979 struct bfd_link_info *info = (struct bfd_link_info *) p;
1980
1981 /* If there are no GOT references for this symbol, we can't fold any
1982 other reference so there's nothing to do. Likewise if there are no
1983 PLT references; GOTPLT references included. */
1984 if (h->root.got.refcount <= 0 || h->root.plt.refcount <= 0)
1985 return true;
1986
1987 /* GOTPLT relocs are supposed to be included into the PLT refcount. */
1988 BFD_ASSERT (h->gotplt_refcount <= h->root.plt.refcount);
1989
1990 if (h->gotplt_refcount == h->root.plt.refcount)
1991 {
4d96d128 1992 /* The only PLT references are GOTPLT references, and there are GOT
915e5146
HPN		 1993 references. Convert PLT to GOT references. */
1994 if (! elf_cris_adjust_gotplt_to_got (h, info))
1995 return false;
1996
1997 /* Clear the PLT references, so no PLT will be created. */
1998 h->root.plt.offset = (bfd_vma) -1;
1999 }
2000
2001 return true;
2002}
2003
2004/* Our own version of hide_symbol, so that we can adjust a GOTPLT reloc
2005 to use a GOT entry (and create one) rather than requiring a GOTPLT
2006 entry. */
2007
2008static void
e5094212 2009elf_cris_hide_symbol (info, h, force_local)
915e5146
HPN		 2010 struct bfd_link_info *info;
2011 struct elf_link_hash_entry *h;
e5094212 2012 boolean force_local;
915e5146
HPN		 2013{
2014 elf_cris_adjust_gotplt_to_got ((struct elf_cris_link_hash_entry *) h, info);
2015
e5094212 2016 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
915e5146
HPN		 2017}
2018
2019/* Adjust a symbol defined by a dynamic object and referenced by a
2020 regular object. The current definition is in some section of the
2021 dynamic object, but we're not including those sections. We have to
2022 change the definition to something the rest of the link can
2023 understand. */
2024
2025static boolean
2026elf_cris_adjust_dynamic_symbol (info, h)
2027 struct bfd_link_info *info;
2028 struct elf_link_hash_entry *h;
2029{
2030 bfd *dynobj;
2031 asection *s;
2032 unsigned int power_of_two;
2033
2034 dynobj = elf_hash_table (info)->dynobj;
2035
2036 /* Make sure we know what is going on here. */
2037 BFD_ASSERT (dynobj != NULL
2038 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2039 || h->weakdef != NULL
2040 || ((h->elf_link_hash_flags
2041 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2042 && (h->elf_link_hash_flags
2043 & ELF_LINK_HASH_REF_REGULAR) != 0
2044 && (h->elf_link_hash_flags
2045 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2046
2047 /* If this is a function, put it in the procedure linkage table. We
2048 will fill in the contents of the procedure linkage table later,
2049 when we know the address of the .got section. */
2050 if (h->type == STT_FUNC
2051 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2052 {
6849c52f
HPN		 2053 /* If we link a program (not a DSO), we'll get rid of unnecessary
2054 PLT entries; we point to the actual symbols -- even for pic
2055 relocs, because a program built with -fpic should have the same
2056 result as one built without -fpic, specifically considering weak
2057 symbols.
2058 FIXME: m68k and i386 differ here, for unclear reasons. */
915e5146 2059 if (! info->shared
6849c52f 2060 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0)
915e5146
HPN		 2061 {
2062 /* This case can occur if we saw a PLT reloc in an input file,
6849c52f
HPN		 2063 but the symbol was not defined by a dynamic object. In such
2064 a case, we don't actually need to build a procedure linkage
2065 table, and we can just do an absolute or PC reloc instead, or
4d96d128 2066 change a .got.plt index to a .got index for GOTPLT relocs. */
915e5146 2067 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
6849c52f 2068 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
915e5146 2069 h->plt.offset = (bfd_vma) -1;
915e5146
HPN		 2070 return
2071 elf_cris_adjust_gotplt_to_got ((struct
2072 elf_cris_link_hash_entry *) h,
2073 info);
2074 }
2075
2076 /* If there are only GOT references and GOTPLT references to this
2077 PLT entry, get rid of the PLT. */
2078 if (! elf_cris_try_fold_plt_to_got ((struct elf_cris_link_hash_entry *)
2079 h, info))
2080 return false;
2081
2082 /* GC or folding may have rendered this entry unused. */
2083 if (h->plt.refcount <= 0)
2084 {
2085 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2086 h->plt.offset = (bfd_vma) -1;
2087 return true;
2088 }
2089
2090 /* Make sure this symbol is output as a dynamic symbol. */
2091 if (h->dynindx == -1)
2092 {
2093 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2094 return false;
2095 }
2096
2097 s = bfd_get_section_by_name (dynobj, ".plt");
2098 BFD_ASSERT (s != NULL);
2099
2100 /* If this is the first .plt entry, make room for the special
2101 first entry. */
2102 if (s->_raw_size == 0)
2103 s->_raw_size += PLT_ENTRY_SIZE;
2104
2105 /* If this symbol is not defined in a regular file, and we are
2106 not generating a shared library, then set the symbol to this
6849c52f 2107 location in the .plt. */
915e5146
HPN		 2108 if (!info->shared
2109 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2110 {
2111 h->root.u.def.section = s;
2112 h->root.u.def.value = s->_raw_size;
2113 }
2114
4d96d128
HPN		 2115 /* If there's already a GOT entry, use that, not a .got.plt. A
2116 GOT field still has a reference count when we get here; it's
2117 not yet changed to an offset. */
915e5146
HPN		 2118 if (h->got.refcount > 0)
2119 {
2120 h->got.refcount += h->plt.refcount;
2121
2122 /* Mark the PLT offset to use the GOT entry by setting the low
2123 bit in the plt offset; it is always a multiple of
2124 pointer-size. */
2125 BFD_ASSERT ((s->_raw_size & 3) == 0);
2126
2127 /* Change the PLT refcount to an offset. */
2128 h->plt.offset = s->_raw_size;
2129
2130 /* By not setting gotplt_offset (i.e. it remains at 0), we signal
2131 that the got entry should be used instead. */
2132 BFD_ASSERT (((struct elf_cris_link_hash_entry *)
2133 h)->gotplt_offset == 0);
2134
2135 /* Make room for this entry. */
2136 s->_raw_size += PLT_ENTRY_SIZE;
2137
2138 return true;
2139 }
2140
2141 /* No GOT reference for this symbol; prepare for an ordinary PLT. */
2142 h->plt.offset = s->_raw_size;
2143
2144 /* Make room for this entry. */
2145 s->_raw_size += PLT_ENTRY_SIZE;
2146
2147 /* We also need to make an entry in the .got.plt section, which
2148 will be placed in the .got section by the linker script. */
2149 ((struct elf_cris_link_hash_entry *) h)->gotplt_offset
2150 = elf_cris_hash_table (info)->next_gotplt_entry;
2151 elf_cris_hash_table (info)->next_gotplt_entry += 4;
2152
2153 s = bfd_get_section_by_name (dynobj, ".got.plt");
2154 BFD_ASSERT (s != NULL);
2155 s->_raw_size += 4;
2156
2157 /* We also need to make an entry in the .rela.plt section. */
2158
2159 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2160 BFD_ASSERT (s != NULL);
2161 s->_raw_size += sizeof (Elf32_External_Rela);
2162
2163 return true;
2164 }
2165
2166 /* Reinitialize the plt offset now that it is not used as a reference
2167 count any more. */
2168 h->plt.offset = (bfd_vma) -1;
2169
2170 /* If this is a weak symbol, and there is a real definition, the
2171 processor independent code will have arranged for us to see the
2172 real definition first, and we can just use the same value. */
2173 if (h->weakdef != NULL)
2174 {
2175 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2176 || h->weakdef->root.type == bfd_link_hash_defweak);
2177 h->root.u.def.section = h->weakdef->root.u.def.section;
2178 h->root.u.def.value = h->weakdef->root.u.def.value;
2179 return true;
2180 }
2181
2182 /* This is a reference to a symbol defined by a dynamic object which
2183 is not a function. */
2184
2185 /* If we are creating a shared library, we must presume that the
2186 only references to the symbol are via the global offset table.
2187 For such cases we need not do anything here; the relocations will
2188 be handled correctly by relocate_section. */
2189 if (info->shared)
2190 return true;
2191
2192 /* If there are no references to this symbol that do not use the
2193 GOT, we don't need to generate a copy reloc. */
2194 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
2195 return true;
2196
2197 /* We must allocate the symbol in our .dynbss section, which will
2198 become part of the .bss section of the executable. There will be
2199 an entry for this symbol in the .dynsym section. The dynamic
2200 object will contain position independent code, so all references
2201 from the dynamic object to this symbol will go through the global
2202 offset table. The dynamic linker will use the .dynsym entry to
2203 determine the address it must put in the global offset table, so
2204 both the dynamic object and the regular object will refer to the
2205 same memory location for the variable. */
2206
2207 s = bfd_get_section_by_name (dynobj, ".dynbss");
2208 BFD_ASSERT (s != NULL);
2209
2210 /* We must generate a R_CRIS_COPY reloc to tell the dynamic linker to
2211 copy the initial value out of the dynamic object and into the
2212 runtime process image. We need to remember the offset into the
2213 .rela.bss section we are going to use. */
2214 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2215 {
2216 asection *srel;
2217
2218 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
2219 BFD_ASSERT (srel != NULL);
2220 srel->_raw_size += sizeof (Elf32_External_Rela);
2221 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2222 }
2223
2224 /* Historic precedent: m68k and i386 allow max 8-byte alignment for the
2225 thing to copy; so do we. */
2226
2227 /* We need to figure out the alignment required for this symbol. I
2228 have no idea how ELF linkers handle this. */
2229 power_of_two = bfd_log2 (h->size);
2230 if (power_of_two > 3)
2231 power_of_two = 3;
2232
2233 /* Apply the required alignment. */
2234 s->_raw_size = BFD_ALIGN (s->_raw_size,
2235 (bfd_size_type) (1 << power_of_two));
2236 if (power_of_two > bfd_get_section_alignment (dynobj, s))
2237 {
2238 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
2239 return false;
2240 }
2241
2242 /* Define the symbol as being at this point in the section. */
2243 h->root.u.def.section = s;
2244 h->root.u.def.value = s->_raw_size;
2245
2246 /* Increment the section size to make room for the symbol. */
2247 s->_raw_size += h->size;
2248
2249 return true;
2250}
2251
2252/* Look through the relocs for a section during the first phase. */
a7c10850 2253
06c15ad7
HPN		 2254static boolean
2255cris_elf_check_relocs (abfd, info, sec, relocs)
2256 bfd *abfd;
2257 struct bfd_link_info *info;
2258 asection *sec;
2259 const Elf_Internal_Rela *relocs;
2260{
915e5146 2261 bfd *dynobj;
06c15ad7
HPN		 2262 Elf_Internal_Shdr *symtab_hdr;
2263 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
915e5146 2264 bfd_signed_vma *local_got_refcounts;
06c15ad7
HPN		 2265 const Elf_Internal_Rela *rel;
2266 const Elf_Internal_Rela *rel_end;
915e5146
HPN		 2267 asection *sgot;
2268 asection *srelgot;
2269 asection *sreloc;
a7c10850 2270
06c15ad7
HPN		 2271 if (info->relocateable)
2272 return true;
a7c10850 2273
915e5146 2274 dynobj = elf_hash_table (info)->dynobj;
06c15ad7
HPN		 2275 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2276 sym_hashes = elf_sym_hashes (abfd);
a7c10850 2277 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
915e5146
HPN		 2278 local_got_refcounts = elf_local_got_refcounts (abfd);
2279
2280 sgot = NULL;
2281 srelgot = NULL;
2282 sreloc = NULL;
2283
06c15ad7
HPN		 2284 if (!elf_bad_symtab (abfd))
2285 sym_hashes_end -= symtab_hdr->sh_info;
a7c10850 2286
06c15ad7
HPN		 2287 rel_end = relocs + sec->reloc_count;
2288 for (rel = relocs; rel < rel_end; rel++)
2289 {
2290 struct elf_link_hash_entry *h;
2291 unsigned long r_symndx;
915e5146 2292 enum elf_cris_reloc_type r_type;
a7c10850 2293
06c15ad7
HPN		 2294 r_symndx = ELF32_R_SYM (rel->r_info);
2295 if (r_symndx < symtab_hdr->sh_info)
2296 h = NULL;
2297 else
2298 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
a7c10850 2299
915e5146
HPN		 2300 r_type = ELF32_R_TYPE (rel->r_info);
2301
2302 /* Some relocs require linker-created sections; we need to hang them
2303 on the first input bfd we found that contained dynamic relocs. */
2304 switch (r_type)
2305 {
2306 case R_CRIS_16_GOT:
2307 case R_CRIS_32_GOT:
2308 case R_CRIS_32_GOTREL:
2309 case R_CRIS_32_PLT_GOTREL:
2310 case R_CRIS_32_PLT_PCREL:
2311 case R_CRIS_16_GOTPLT:
2312 case R_CRIS_32_GOTPLT:
2313 if (dynobj == NULL)
2314 {
2315 elf_hash_table (info)->dynobj = dynobj = abfd;
2316
2317 /* Create the .got section, so we can assume it's always
2318 present whenever there's a dynobj. */
2319 if (!_bfd_elf_create_got_section (dynobj, info))
2320 return false;
2321 }
2322 break;
2323
2324 default:
2325 break;
2326 }
2327
2328 /* Some relocs require a global offset table (but perhaps not a
2329 specific GOT entry). */
4d96d128 2330 switch (r_type)
915e5146 2331 {
44aa49bb
HPN		 2332 /* For R_CRIS_16_GOTPLT and R_CRIS_32_GOTPLT, we need a GOT
2333 entry only for local symbols. Unfortunately, we don't know
2334 until later on if there's a version script that forces the
2335 symbol local. We must have the .rela.got section in place
2336 before we know if the symbol looks global now, so we need
2337 to treat the reloc just like for R_CRIS_16_GOT and
2338 R_CRIS_32_GOT. */
2339 case R_CRIS_16_GOTPLT:
2340 case R_CRIS_32_GOTPLT:
915e5146
HPN		 2341 case R_CRIS_16_GOT:
2342 case R_CRIS_32_GOT:
44aa49bb
HPN		 2343 if (srelgot == NULL
2344 && (h != NULL || info->shared))
2345 {
2346 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2347 if (srelgot == NULL)
2348 {
2349 srelgot = bfd_make_section (dynobj, ".rela.got");
2350 if (srelgot == NULL
2351 || !bfd_set_section_flags (dynobj, srelgot,
2352 (SEC_ALLOC
2353 | SEC_LOAD
2354 | SEC_HAS_CONTENTS
2355 | SEC_IN_MEMORY
2356 | SEC_LINKER_CREATED
2357 | SEC_READONLY))
2358 || !bfd_set_section_alignment (dynobj, srelgot, 2))
2359 return false;
2360 }
2361 }
2362 /* Fall through. */
2363
915e5146
HPN		 2364 case R_CRIS_32_GOTREL:
2365 case R_CRIS_32_PLT_GOTREL:
2366 if (sgot == NULL)
2367 sgot = bfd_get_section_by_name (dynobj, ".got");
2368
2369 if (local_got_refcounts == NULL)
2370 {
dc810e39 2371 bfd_size_type amt;
915e5146
HPN		 2372
2373 /* We use index local_got_refcounts[-1] to count all
2374 GOT-relative relocations that do not have explicit
2375 GOT entries. */
dc810e39
AM		 2376 amt = symtab_hdr->sh_info + 1;
2377 amt *= sizeof (bfd_signed_vma);
51b64d56 2378 local_got_refcounts = ((bfd_signed_vma *) bfd_zalloc (abfd, amt));
915e5146
HPN		 2379 if (local_got_refcounts == NULL)
2380 return false;
915e5146
HPN		 2381
2382 local_got_refcounts++;
2383 elf_local_got_refcounts (abfd) = local_got_refcounts;
2384 }
2385 break;
2386
2387 default:
2388 break;
2389 }
2390
4d96d128 2391 switch (r_type)
06c15ad7 2392 {
915e5146
HPN		 2393 case R_CRIS_16_GOTPLT:
2394 case R_CRIS_32_GOTPLT:
2395 /* Mark that we need a GOT entry if the PLT entry (and its GOT
2396 entry) is eliminated. We can only do this for a non-local
2397 symbol. */
2398 if (h != NULL)
2399 {
2400 ((struct elf_cris_link_hash_entry *) h)->gotplt_refcount++;
2401 goto handle_gotplt_reloc;
2402 }
2403 /* If h is NULL then this is a local symbol, and we must make a
2404 GOT entry for it, so handle it like a GOT reloc. */
2405 /* Fall through. */
2406
2407 case R_CRIS_16_GOT:
2408 case R_CRIS_32_GOT:
2409 /* This symbol requires a global offset table entry. */
915e5146
HPN		 2410 if (h != NULL)
2411 {
51b64d56 2412 if (h->got.refcount == 0)
915e5146 2413 {
915e5146
HPN		 2414 /* Make sure this symbol is output as a dynamic symbol. */
2415 if (h->dynindx == -1)
2416 {
2417 if (!bfd_elf32_link_record_dynamic_symbol (info, h))
2418 return false;
2419 }
2420
2421 /* Allocate space in the .got section. */
2422 sgot->_raw_size += 4;
2423 /* Allocate relocation space. */
2424 srelgot->_raw_size += sizeof (Elf32_External_Rela);
2425 }
51b64d56 2426 h->got.refcount++;
915e5146
HPN		 2427 }
2428 else
2429 {
2430 /* This is a global offset table entry for a local symbol. */
51b64d56 2431 if (local_got_refcounts[r_symndx] == 0)
915e5146 2432 {
915e5146
HPN		 2433 sgot->_raw_size += 4;
2434 if (info->shared)
2435 {
2436 /* If we are generating a shared object, we need to
2437 output a R_CRIS_RELATIVE reloc so that the dynamic
2438 linker can adjust this GOT entry. */
2439 srelgot->_raw_size += sizeof (Elf32_External_Rela);
2440 }
2441 }
51b64d56 2442 local_got_refcounts[r_symndx]++;
915e5146
HPN		 2443 }
2444 break;
2445
2446 case R_CRIS_32_GOTREL:
2447 /* This reference requires a global offset table.
2448 FIXME: The actual refcount isn't used currently; the .got
2449 section can't be removed if there were any references in the
2450 input. */
2451 local_got_refcounts[-1]++;
2452 break;
2453
2454 handle_gotplt_reloc:
2455
2456 case R_CRIS_32_PLT_GOTREL:
2457 /* This reference requires a global offset table. */
2458 local_got_refcounts[-1]++;
2459 /* Fall through. */
2460
2461 case R_CRIS_32_PLT_PCREL:
2462 /* This symbol requires a procedure linkage table entry. We
2463 actually build the entry in adjust_dynamic_symbol,
2464 because this might be a case of linking PIC code which is
2465 never referenced by a dynamic object, in which case we
2466 don't need to generate a procedure linkage table entry
2467 after all. */
2468
2469 /* If this is a local symbol, we resolve it directly without
2470 creating a procedure linkage table entry. */
0a4787a0 2471 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
915e5146
HPN		 2472 continue;
2473
2474 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
51b64d56 2475 h->plt.refcount++;
915e5146
HPN		 2476 break;
2477
2478 case R_CRIS_8:
2479 case R_CRIS_16:
2480 case R_CRIS_32:
2481 /* Let's help debug shared library creation. Any of these
2482 relocs can be used in shared libs, but pages containing them
2483 cannot be shared. Don't warn for sections we don't care
2484 about, such as debug sections or non-constant sections. We
2485 can't help tables of (global) function pointers, for example,
2486 though they must be emitted in a data section to avoid having
2487 impure text sections. */
2488 if (info->shared
2489 && (sec->flags & SEC_ALLOC) != 0
2490 && (sec->flags & SEC_READONLY) != 0)
2491 {
2492 /* FIXME: How do we make this optionally a warning only? */
8f615d07
AM		 2493 (*_bfd_error_handler)
2494 (_("%s, section %s:\n relocation %s should not be used in a shared object; recompile with -fPIC"),
2495 bfd_archive_filename (abfd),
2496 sec->name,
2497 cris_elf_howto_table[r_type].name);
915e5146
HPN		 2498 }
2499 /* Fall through. */
2500
2501 case R_CRIS_8_PCREL:
2502 case R_CRIS_16_PCREL:
2503 case R_CRIS_32_PCREL:
2504 if (h != NULL)
2505 {
2506 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
2507
2508 /* Make sure a plt entry is created for this symbol if it
2509 turns out to be a function defined by a dynamic object. */
0a4787a0
HPN		 2510 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2511 h->plt.refcount++;
915e5146
HPN		 2512 }
2513
2514 /* If we are creating a shared library and this is not a local
2515 symbol, we need to copy the reloc into the shared library.
2516 However when linking with -Bsymbolic and this is a global
2517 symbol which is defined in an object we are including in the
2518 link (i.e., DEF_REGULAR is set), then we can resolve the
2519 reloc directly. At this point we have not seen all the input
2520 files, so it is possible that DEF_REGULAR is not set now but
2521 will be set later (it is never cleared). In case of a weak
2522 definition, DEF_REGULAR may be cleared later by a strong
2523 definition in a shared library. We account for that
2524 possibility below by storing information in the relocs_copied
2525 field of the hash table entry. A similar situation occurs
2526 when creating shared libraries and symbol visibility changes
2527 render the symbol local. */
2528
2529 /* No need to do anything if we're not creating a shared object. */
2530 if (! info->shared)
2531 break;
2532
2533 /* We don't need to handle relocs into sections not going into
2534 the "real" output. */
2535 if ((sec->flags & SEC_ALLOC) == 0)
2536 break;
2537
2538 /* We can only eliminate PC-relative relocs. */
2539 if (r_type == R_CRIS_8_PCREL
2540 || r_type == R_CRIS_16_PCREL
2541 || r_type == R_CRIS_32_PCREL)
2542 {
2543 /* If the symbol is local, then we can eliminate the reloc. */
0a4787a0 2544 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
915e5146
HPN		 2545 break;
2546
2547 /* If this is with -Bsymbolic and the symbol isn't weak, and
2548 is defined by an ordinary object (the ones we include in
2549 this shared library) then we can also eliminate the
2550 reloc. See comment above for more eliminable cases which
2551 we can't identify at this time. */
2552 if (info->symbolic
2553 && h->root.type != bfd_link_hash_defweak
2554 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
2555 break;
2556 }
2557
2558 /* We create a reloc section in dynobj and make room for this
2559 reloc. */
2560 if (sreloc == NULL)
2561 {
2562 const char *name;
2563
2564 name = (bfd_elf_string_from_elf_section
2565 (abfd,
2566 elf_elfheader (abfd)->e_shstrndx,
2567 elf_section_data (sec)->rel_hdr.sh_name));
2568 if (name == NULL)
2569 return false;
2570
2571 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2572 && strcmp (bfd_get_section_name (abfd, sec),
2573 name + 5) == 0);
2574
2575 sreloc = bfd_get_section_by_name (dynobj, name);
2576 if (sreloc == NULL)
2577 {
2578 sreloc = bfd_make_section (dynobj, name);
2579 if (sreloc == NULL
2580 || !bfd_set_section_flags (dynobj, sreloc,
2581 (SEC_ALLOC
2582 | SEC_LOAD
2583 | SEC_HAS_CONTENTS
2584 | SEC_IN_MEMORY
2585 | SEC_LINKER_CREATED
2586 | SEC_READONLY))
2587 || !bfd_set_section_alignment (dynobj, sreloc, 2))
2588 return false;
2589 }
99e4ae17
AJ		 2590 if (sec->flags & SEC_READONLY)
2591 info->flags |= DF_TEXTREL;
915e5146
HPN		 2592 }
2593
2594 sreloc->_raw_size += sizeof (Elf32_External_Rela);
2595
2596 /* If we are linking with -Bsymbolic, we count the number of PC
2597 relative relocations we have entered for this symbol, so that
2598 we can discard them again if the symbol is later defined by a
2599 regular object. We know that h is really a pointer to an
2600 elf_cris_link_hash_entry. */
4d96d128
HPN		 2601 if ((r_type == R_CRIS_8_PCREL
2602 || r_type == R_CRIS_16_PCREL
2603 || r_type == R_CRIS_32_PCREL)
915e5146
HPN		 2604 && info->symbolic)
2605 {
2606 struct elf_cris_link_hash_entry *eh;
2607 struct elf_cris_pcrel_relocs_copied *p;
2608
2609 eh = (struct elf_cris_link_hash_entry *) h;
2610
2611 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2612 if (p->section == sreloc)
2613 break;
2614
2615 if (p == NULL)
2616 {
2617 p = ((struct elf_cris_pcrel_relocs_copied *)
dc810e39 2618 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
915e5146
HPN		 2619 if (p == NULL)
2620 return false;
2621 p->next = eh->pcrel_relocs_copied;
2622 eh->pcrel_relocs_copied = p;
2623 p->section = sreloc;
2624 p->count = 0;
2625 }
2626
2627 ++p->count;
2628 }
2629 break;
2630
06c15ad7
HPN		 2631 /* This relocation describes the C++ object vtable hierarchy.
2632 Reconstruct it for later use during GC. */
2633 case R_CRIS_GNU_VTINHERIT:
2634 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2635 return false;
2636 break;
a7c10850 2637
06c15ad7
HPN		 2638 /* This relocation describes which C++ vtable entries are actually
2639 used. Record for later use during GC. */
2640 case R_CRIS_GNU_VTENTRY:
2641 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2642 return false;
2643 break;
4d96d128
HPN		 2644
2645 default:
2646 /* Other relocs do not appear here. */
2647 bfd_set_error (bfd_error_bad_value);
2648 return false;
06c15ad7
HPN		 2649 }
2650 }
a7c10850 2651
06c15ad7
HPN		 2652 return true;
2653}
4da81684 2654
915e5146
HPN		 2655/* Set the sizes of the dynamic sections. */
2656
2657static boolean
2658elf_cris_size_dynamic_sections (output_bfd, info)
99e4ae17 2659 bfd *output_bfd ATTRIBUTE_UNUSED;
915e5146
HPN		 2660 struct bfd_link_info *info;
2661{
2662 bfd *dynobj;
2663 asection *s;
2664 boolean plt;
2665 boolean relocs;
915e5146
HPN		 2666
2667 dynobj = elf_hash_table (info)->dynobj;
2668 BFD_ASSERT (dynobj != NULL);
2669
2670 if (elf_hash_table (info)->dynamic_sections_created)
2671 {
2672 /* Set the contents of the .interp section to the interpreter. */
2673 if (!info->shared)
2674 {
2675 s = bfd_get_section_by_name (dynobj, ".interp");
2676 BFD_ASSERT (s != NULL);
2677 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2678 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2679 }
2680 }
2681 else
2682 {
2683 /* Adjust all expected GOTPLT uses to use a GOT entry instead. */
2684 elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2685 elf_cris_adjust_gotplt_to_got,
2686 (PTR) info);
2687
2688 /* We may have created entries in the .rela.got section.
2689 However, if we are not creating the dynamic sections, we will
2690 not actually use these entries. Reset the size of .rela.got,
2691 which will cause it to get stripped from the output file
2692 below. */
2693 s = bfd_get_section_by_name (dynobj, ".rela.got");
2694 if (s != NULL)
2695 s->_raw_size = 0;
2696 }
2697
2698 /* If this is a -Bsymbolic shared link, then we need to discard all PC
2699 relative relocs against symbols defined in a regular object. We
2700 allocated space for them in the check_relocs routine, but we will not
2701 fill them in in the relocate_section routine. We also discard space
2702 for relocs that have become for local symbols due to symbol
4d96d128
HPN		 2703 visibility changes. For programs, we discard space for relocs for
2704 symbols not referenced by any dynamic object. */
915e5146
HPN		 2705 if (info->shared)
2706 elf_cris_link_hash_traverse (elf_cris_hash_table (info),
4d96d128
HPN		 2707 elf_cris_discard_excess_dso_dynamics,
2708 (PTR) info);
2709 else
2710 elf_cris_link_hash_traverse (elf_cris_hash_table (info),
2711 elf_cris_discard_excess_program_dynamics,
915e5146
HPN		 2712 (PTR) info);
2713
2714 /* The check_relocs and adjust_dynamic_symbol entry points have
2715 determined the sizes of the various dynamic sections. Allocate
2716 memory for them. */
2717 plt = false;
2718 relocs = false;
915e5146
HPN		 2719 for (s = dynobj->sections; s != NULL; s = s->next)
2720 {
2721 const char *name;
2722 boolean strip;
2723
2724 if ((s->flags & SEC_LINKER_CREATED) == 0)
2725 continue;
2726
2727 /* It's OK to base decisions on the section name, because none
2728 of the dynobj section names depend upon the input files. */
2729 name = bfd_get_section_name (dynobj, s);
2730
2731 strip = false;
2732
2733 if (strcmp (name, ".plt") == 0)
2734 {
2735 if (s->_raw_size == 0)
2736 {
2737 /* Strip this section if we don't need it; see the
2738 comment below. */
2739 strip = true;
2740 }
2741 else
2742 {
2743 /* Remember whether there is a PLT. */
2744 plt = true;
2745 }
2746 }
2747 else if (strncmp (name, ".rela", 5) == 0)
2748 {
2749 if (s->_raw_size == 0)
2750 {
2751 /* If we don't need this section, strip it from the
2752 output file. This is mostly to handle .rela.bss and
2753 .rela.plt. We must create both sections in
2754 create_dynamic_sections, because they must be created
2755 before the linker maps input sections to output
2756 sections. The linker does that before
2757 adjust_dynamic_symbol is called, and it is that
2758 function which decides whether anything needs to go
2759 into these sections. */
2760 strip = true;
2761 }
2762 else
2763 {
915e5146
HPN		 2764 /* Remember whether there are any reloc sections other
2765 than .rela.plt. */
2766 if (strcmp (name, ".rela.plt") != 0)
915e5146
HPN		 2767 relocs = true;
2768
915e5146
HPN		 2769 /* We use the reloc_count field as a counter if we need
2770 to copy relocs into the output file. */
2771 s->reloc_count = 0;
2772 }
2773 }
2774 else if (strncmp (name, ".got", 4) != 0)
2775 {
2776 /* It's not one of our sections, so don't allocate space. */
2777 continue;
2778 }
2779
2780 if (strip)
2781 {
2782 _bfd_strip_section_from_output (info, s);
2783 continue;
2784 }
2785
2786 /* Allocate memory for the section contents. We use bfd_zalloc here
2787 in case unused entries are not reclaimed before the section's
2788 contents are written out. This should not happen, but this way
2789 if it does, we will not write out garbage. For reloc sections,
2790 this will make entries have the type R_CRIS_NONE. */
2791 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2792 if (s->contents == NULL && s->_raw_size != 0)
2793 return false;
2794 }
2795
2796 if (elf_hash_table (info)->dynamic_sections_created)
2797 {
2798 /* Add some entries to the .dynamic section. We fill in the
2799 values later, in elf_cris_finish_dynamic_sections, but we
2800 must add the entries now so that we get the correct size for
2801 the .dynamic section. The DT_DEBUG entry is filled in by the
2802 dynamic linker and used by the debugger. */
dc810e39
AM		 2803#define add_dynamic_entry(TAG, VAL) \
2804 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2805
915e5146
HPN		 2806 if (!info->shared)
2807 {
dc810e39 2808 if (!add_dynamic_entry (DT_DEBUG, 0))
915e5146
HPN		 2809 return false;
2810 }
2811
2812 if (plt)
2813 {
dc810e39
AM		 2814 if (!add_dynamic_entry (DT_PLTGOT, 0)
2815 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2816 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2817 || !add_dynamic_entry (DT_JMPREL, 0))
915e5146
HPN		 2818 return false;
2819 }
2820
2821 if (relocs)
2822 {
dc810e39
AM		 2823 if (!add_dynamic_entry (DT_RELA, 0)
2824 || !add_dynamic_entry (DT_RELASZ, 0)
2825 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
915e5146
HPN		 2826 return false;
2827 }
2828
99e4ae17 2829 if ((info->flags & DF_TEXTREL) != 0)
915e5146 2830 {
dc810e39 2831 if (!add_dynamic_entry (DT_TEXTREL, 0))
915e5146
HPN		 2832 return false;
2833 info->flags |= DF_TEXTREL;
2834 }
2835 }
dc810e39 2836#undef add_dynamic_entry
915e5146
HPN		 2837
2838 return true;
2839}
2840
2841/* This function is called via elf_cris_link_hash_traverse if we are
2842 creating a shared object. In the -Bsymbolic case, it discards the
2843 space allocated to copy PC relative relocs against symbols which
2844 are defined in regular objects. For the normal non-symbolic case,
2845 we also discard space for relocs that have become local due to
2846 symbol visibility changes. We allocated space for them in the
2847 check_relocs routine, but we won't fill them in in the
2848 relocate_section routine. */
2849
2850static boolean
4d96d128 2851elf_cris_discard_excess_dso_dynamics (h, inf)
915e5146
HPN		 2852 struct elf_cris_link_hash_entry *h;
2853 PTR inf;
2854{
2855 struct elf_cris_pcrel_relocs_copied *s;
2856 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2857
e92d460e
AM		 2858 if (h->root.root.type == bfd_link_hash_warning)
2859 h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
2860
915e5146
HPN		 2861 /* If a symbol has been forced local or we have found a regular
2862 definition for the symbolic link case, then we won't be needing
2863 any relocs. */
2864 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
2865 && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
2866 || info->symbolic))
2867 {
2868 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
4d96d128
HPN		 2869 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rela);
2870 }
2871
2872 return true;
2873}
2874
2875/* This function is called via elf_cris_link_hash_traverse if we are *not*
2876 creating a shared object. We discard space for relocs for symbols put
2877 in the .got, but which we found we do not have to resolve at run-time. */
2878
2879static boolean
2880elf_cris_discard_excess_program_dynamics (h, inf)
2881 struct elf_cris_link_hash_entry *h;
2882 PTR inf;
2883{
2884 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2885
e92d460e
AM		 2886 if (h->root.root.type == bfd_link_hash_warning)
2887 h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
2888
4d96d128
HPN		 2889 /* If we're not creating a shared library and have a symbol which is
2890 referred to by .got references, but the symbol is defined locally,
6849c52f
HPN		 2891 (or rather, not not defined by a DSO) then lose the reloc for the
2892 .got (don't allocate room for it). */
2893 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0)
4d96d128
HPN		 2894 {
2895 if (h->root.got.refcount > 0
2896 /* The size of this section is only valid and in sync with the
2897 various reference counts if we do dynamic; don't decrement it
2898 otherwise. */
2899 && elf_hash_table (info)->dynamic_sections_created)
2900 {
2901 bfd *dynobj = elf_hash_table (info)->dynobj;
2902 asection *srelgot;
2903
2904 BFD_ASSERT (dynobj != NULL);
99c79b2e 2905
4d96d128
HPN		 2906 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2907
2908 BFD_ASSERT (srelgot != NULL);
2909
2910 srelgot->_raw_size -= sizeof (Elf32_External_Rela);
2911 }
2912
2913 /* If the locally-defined symbol isn't used by a DSO, then we don't
2914 have to export it as a dynamic symbol. This was already done for
2915 functions; doing this for all symbols would presumably not
e5dfef09
HPN		 2916 introduce new problems. Of course we don't do this if we're
2917 exporting all dynamic symbols. */
0741c7be
HPN		 2918 if (! info->export_dynamic
2919 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
e5dfef09
HPN		 2920 {
2921 h->root.dynindx = -1;
2922 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2923 h->root.dynstr_index);
2924 }
915e5146
HPN		 2925 }
2926
2927 return true;
2928}
2929
2930/* Reject a file depending on presence and expectation of prefixed
2931 underscores on symbols. */
4da81684
HPN		 2932
2933static boolean
2934cris_elf_object_p (abfd)
2935 bfd *abfd;
2936{
2937 if ((elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE))
2938 return (bfd_get_symbol_leading_char (abfd) == '_');
2939 else
2940 return (bfd_get_symbol_leading_char (abfd) == 0);
2941}
2942
2943/* Mark presence or absence of leading underscore. */
2944
2945static void
2946cris_elf_final_write_processing (abfd, linker)
2947 bfd *abfd;
2948 boolean linker ATTRIBUTE_UNUSED;
2949{
2950 if (bfd_get_symbol_leading_char (abfd) == '_')
2951 elf_elfheader (abfd)->e_flags |= EF_CRIS_UNDERSCORE;
2952 else
2953 elf_elfheader (abfd)->e_flags &= ~EF_CRIS_UNDERSCORE;
2954}
2955
2956/* Display the flags field. */
2957
2958static boolean
2959cris_elf_print_private_bfd_data (abfd, ptr)
2960 bfd *abfd;
2961 PTR ptr;
2962{
2963 FILE *file = (FILE *) ptr;
2964
2965 BFD_ASSERT (abfd != NULL && ptr != NULL)
2966
2967 _bfd_elf_print_private_bfd_data (abfd, ptr);
2968
2969 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2970
2971 if (elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE)
2972 fprintf (file, _(" [symbols have a _ prefix]"));
2973
2974 fputc ('\n', file);
2975 return true;
2976}
2977
2978/* Don't mix files with and without a leading underscore. */
2979
2980static boolean
2981cris_elf_merge_private_bfd_data (ibfd, obfd)
2982 bfd *ibfd;
2983 bfd *obfd;
2984{
2985 flagword old_flags, new_flags;
2986
82e51918 2987 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
4da81684
HPN		 2988 return false;
2989
2990 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2991 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2992 return true;
2993
2994 if (! elf_flags_init (obfd))
2995 {
2996 /* This happens when ld starts out with a 'blank' output file. */
2997 elf_flags_init (obfd) = true;
2998
2999 /* Set flags according to current bfd_target. */
3000 cris_elf_final_write_processing (obfd, false);
3001 }
3002
3003 old_flags = elf_elfheader (obfd)->e_flags;
3004 new_flags = elf_elfheader (ibfd)->e_flags;
3005
3006 /* Is this good or bad? We'll follow with other excluding flags. */
3007 if ((old_flags & EF_CRIS_UNDERSCORE) != (new_flags & EF_CRIS_UNDERSCORE))
3008 {
3009 (*_bfd_error_handler)
3010 ((new_flags & EF_CRIS_UNDERSCORE)
3011 ? _("%s: uses _-prefixed symbols, but writing file with non-prefixed symbols")
3012 : _("%s: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
8f615d07 3013 bfd_archive_filename (ibfd));
4da81684
HPN		 3014 bfd_set_error (bfd_error_bad_value);
3015 return false;
3016 }
3017
3018 return true;
3019}
99e4ae17
AJ		 3020
3021
3022static enum elf_reloc_type_class
f51e552e
AM		 3023elf_cris_reloc_type_class (rela)
3024 const Elf_Internal_Rela *rela;
99e4ae17 3025{
f51e552e 3026 switch ((int) ELF32_R_TYPE (rela->r_info))
99e4ae17
AJ		 3027 {
3028 case R_CRIS_RELATIVE:
3029 return reloc_class_relative;
3030 case R_CRIS_JUMP_SLOT:
3031 return reloc_class_plt;
3032 case R_CRIS_COPY:
3033 return reloc_class_copy;
3034 default:
3035 return reloc_class_normal;
3036 }
3037}
06c15ad7
HPN		 3038\f
3039#define ELF_ARCH bfd_arch_cris
3040#define ELF_MACHINE_CODE EM_CRIS
3041#define ELF_MAXPAGESIZE 0x2000
3042
3043#define TARGET_LITTLE_SYM bfd_elf32_cris_vec
3044#define TARGET_LITTLE_NAME "elf32-cris"
4da81684 3045#define elf_symbol_leading_char 0
06c15ad7
HPN		 3046
3047#define elf_info_to_howto_rel NULL
3048#define elf_info_to_howto cris_info_to_howto_rela
3049#define elf_backend_relocate_section cris_elf_relocate_section
3050#define elf_backend_gc_mark_hook cris_elf_gc_mark_hook
3051#define elf_backend_gc_sweep_hook cris_elf_gc_sweep_hook
3052#define elf_backend_check_relocs cris_elf_check_relocs
72209a1f
HPN		 3053#define elf_backend_grok_prstatus cris_elf_grok_prstatus
3054#define elf_backend_grok_psinfo cris_elf_grok_psinfo
06c15ad7
HPN		 3055
3056#define elf_backend_can_gc_sections 1
51b64d56 3057#define elf_backend_can_refcount 1
06c15ad7 3058
4da81684
HPN		 3059#define elf_backend_object_p cris_elf_object_p
3060#define elf_backend_final_write_processing \
3061 cris_elf_final_write_processing
3062#define bfd_elf32_bfd_print_private_bfd_data \
3063 cris_elf_print_private_bfd_data
3064#define bfd_elf32_bfd_merge_private_bfd_data \
3065 cris_elf_merge_private_bfd_data
3066
06c15ad7
HPN		 3067#define bfd_elf32_bfd_reloc_type_lookup cris_reloc_type_lookup
3068
915e5146
HPN		 3069#define bfd_elf32_bfd_link_hash_table_create \
3070 elf_cris_link_hash_table_create
3071#define elf_backend_adjust_dynamic_symbol \
3072 elf_cris_adjust_dynamic_symbol
3073#define elf_backend_size_dynamic_sections \
3074 elf_cris_size_dynamic_sections
3075#define elf_backend_finish_dynamic_symbol \
3076 elf_cris_finish_dynamic_symbol
3077#define elf_backend_finish_dynamic_sections \
3078 elf_cris_finish_dynamic_sections
3079#define elf_backend_create_dynamic_sections \
3080 _bfd_elf_create_dynamic_sections
3081#define bfd_elf32_bfd_final_link \
3082 _bfd_elf32_gc_common_final_link
3083#define elf_backend_hide_symbol elf_cris_hide_symbol
99e4ae17 3084#define elf_backend_reloc_type_class elf_cris_reloc_type_class
915e5146
HPN		 3085
3086#define elf_backend_want_got_plt 1
3087#define elf_backend_plt_readonly 1
3088#define elf_backend_want_plt_sym 0
3089#define elf_backend_got_header_size 12
3090#define elf_backend_plt_header_size PLT_ENTRY_SIZE
3091
06c15ad7
HPN		 3092/* Later, we my want to optimize RELA entries into REL entries for dynamic
3093 linking and libraries (if it's a win of any significance). Until then,
3094 take the easy route. */
3095#define elf_backend_may_use_rel_p 0
3096#define elf_backend_may_use_rela_p 1
f0fe0e16 3097#define elf_backend_rela_normal 1
06c15ad7
HPN		 3098
3099#include "elf32-target.h"
4da81684
HPN		 3100
3101#define INCLUDED_TARGET_FILE
3102
3103#undef TARGET_LITTLE_SYM
3104#undef TARGET_LITTLE_NAME
3105#undef elf_symbol_leading_char
3106
3107#define TARGET_LITTLE_SYM bfd_elf32_us_cris_vec
3108#define TARGET_LITTLE_NAME "elf32-us-cris"
3109#define elf_symbol_leading_char '_'
3110
3111#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.329103 seconds and 4 git commands to generate.