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