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