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