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