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