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