OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [bfd/] [elf32-cris.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* CRIS-specific support for 32-bit ELF.
2
   Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3
   2010  Free Software Foundation, Inc.
4
   Contributed by Axis Communications AB.
5
   Written by Hans-Peter Nilsson, based on elf32-fr30.c
6
   PIC and shlib bits based primarily on elf32-m68k.c and elf32-i386.c.
7
 
8
   This file is part of BFD, the Binary File Descriptor library.
9
 
10
   This program is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 3 of the License, or
13
   (at your option) any later version.
14
 
15
   This program is distributed in the hope that it will be useful,
16
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
   GNU General Public License for more details.
19
 
20
   You should have received a copy of the GNU General Public License
21
   along with this program; if not, write to the Free Software
22
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23
   MA 02110-1301, USA.  */
24
 
25
#include "sysdep.h"
26
#include "bfd.h"
27
#include "libbfd.h"
28
#include "elf-bfd.h"
29
#include "elf/cris.h"
30
#include <limits.h>
31
 
32
/* Forward declarations.  */
33
static reloc_howto_type * cris_reloc_type_lookup
34
  PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
35
 
36
static void cris_info_to_howto_rela
37
  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
38
 
39
static bfd_reloc_status_type cris_elf_pcrel_reloc
40
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
41
 
42
static bfd_boolean cris_elf_grok_prstatus
43
  PARAMS ((bfd *abfd, Elf_Internal_Note *note));
44
 
45
static bfd_boolean cris_elf_grok_psinfo
46
  PARAMS ((bfd *abfd, Elf_Internal_Note *note));
47
 
48
static bfd_boolean cris_elf_relocate_section
49
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
50
           Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
51
 
52
static bfd_reloc_status_type cris_final_link_relocate
53
  PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
54
           Elf_Internal_Rela *, bfd_vma));
55
 
56
static bfd_boolean cris_elf_object_p PARAMS ((bfd *));
57
 
58
static void cris_elf_final_write_processing PARAMS ((bfd *, bfd_boolean));
59
 
60
static bfd_boolean cris_elf_set_mach_from_flags
61
  PARAMS ((bfd *, unsigned long int));
62
 
63
static bfd_boolean cris_elf_print_private_bfd_data PARAMS ((bfd *, PTR));
64
 
65
static bfd_boolean cris_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
66
static bfd_boolean cris_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
67
 
68
struct elf_cris_link_hash_entry;
69
static bfd_boolean elf_cris_discard_excess_dso_dynamics
70
  PARAMS ((struct elf_cris_link_hash_entry *, PTR));
71
static bfd_boolean elf_cris_discard_excess_program_dynamics
72
  PARAMS ((struct elf_cris_link_hash_entry *, PTR));
73
static bfd_boolean elf_cris_adjust_gotplt_to_got
74
  PARAMS ((struct elf_cris_link_hash_entry *, PTR));
75
static bfd_boolean elf_cris_try_fold_plt_to_got
76
  PARAMS ((struct elf_cris_link_hash_entry *, PTR));
77
static struct bfd_hash_entry *elf_cris_link_hash_newfunc
78
  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
79
static struct bfd_link_hash_table *elf_cris_link_hash_table_create
80
  PARAMS ((bfd *));
81
static bfd_boolean elf_cris_adjust_dynamic_symbol
82
  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
83
static bfd_boolean cris_elf_check_relocs
84
  PARAMS ((bfd *, struct bfd_link_info *, asection *,
85
           const Elf_Internal_Rela *));
86
 
87
static bfd_boolean elf_cris_size_dynamic_sections
88
  PARAMS ((bfd *, struct bfd_link_info *));
89
static bfd_boolean elf_cris_finish_dynamic_symbol
90
  PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
91
           Elf_Internal_Sym *));
92
static bfd_boolean elf_cris_finish_dynamic_sections
93
  PARAMS ((bfd *, struct bfd_link_info *));
94
static void elf_cris_hide_symbol
95
  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
96
static enum elf_reloc_type_class elf_cris_reloc_type_class
97
  PARAMS ((const Elf_Internal_Rela *));
98
 
99
static reloc_howto_type cris_elf_howto_table [] =
100
{
101
  /* This reloc does nothing.  */
102
  HOWTO (R_CRIS_NONE,           /* type */
103
         0,                      /* rightshift */
104
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
105
         32,                    /* bitsize */
106
         FALSE,                 /* pc_relative */
107
         0,                      /* bitpos */
108
         complain_overflow_bitfield, /* complain_on_overflow */
109
         bfd_elf_generic_reloc, /* special_function */
110
         "R_CRIS_NONE",         /* name */
111
         FALSE,                 /* partial_inplace */
112
         0,                      /* src_mask */
113
         0,                      /* dst_mask */
114
         FALSE),                /* pcrel_offset */
115
 
116
  /* An 8 bit absolute relocation.  */
117
  HOWTO (R_CRIS_8,              /* type */
118
         0,                      /* rightshift */
119
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
120
         8,                     /* bitsize */
121
         FALSE,                 /* pc_relative */
122
         0,                      /* bitpos */
123
         complain_overflow_bitfield, /* complain_on_overflow */
124
         bfd_elf_generic_reloc, /* special_function */
125
         "R_CRIS_8",            /* name */
126
         FALSE,                 /* partial_inplace */
127
         0x0000,                /* src_mask */
128
         0x00ff,                /* dst_mask */
129
         FALSE),                /* pcrel_offset */
130
 
131
  /* A 16 bit absolute relocation.  */
132
  HOWTO (R_CRIS_16,             /* type */
133
         0,                      /* rightshift */
134
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
135
         16,                    /* bitsize */
136
         FALSE,                 /* pc_relative */
137
         0,                      /* bitpos */
138
         complain_overflow_bitfield, /* complain_on_overflow */
139
         bfd_elf_generic_reloc, /* special_function */
140
         "R_CRIS_16",           /* name */
141
         FALSE,                 /* partial_inplace */
142
         0x00000000,            /* src_mask */
143
         0x0000ffff,            /* dst_mask */
144
         FALSE),                /* pcrel_offset */
145
 
146
  /* A 32 bit absolute relocation.  */
147
  HOWTO (R_CRIS_32,             /* type */
148
         0,                      /* rightshift */
149
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
150
         32,                    /* bitsize */
151
         FALSE,                 /* pc_relative */
152
         0,                      /* bitpos */
153
         /* We don't want overflow complaints for 64-bit vma builds
154
            for e.g. sym+0x40000000 (or actually sym-0xc0000000 in
155
            32-bit ELF) where sym=0xc0001234.
156
            Don't do this for the PIC relocs, as we don't expect to
157
            see them with large offsets.  */
158
         complain_overflow_dont, /* complain_on_overflow */
159
         bfd_elf_generic_reloc, /* special_function */
160
         "R_CRIS_32",           /* name */
161
         FALSE,                 /* partial_inplace */
162
         0x00000000,            /* src_mask */
163
         0xffffffff,            /* dst_mask */
164
         FALSE),                /* pcrel_offset */
165
 
166
  /* An 8 bit PC-relative relocation.  */
167
  HOWTO (R_CRIS_8_PCREL,        /* type */
168
         0,                      /* rightshift */
169
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
170
         8,                     /* bitsize */
171
         TRUE,                  /* pc_relative */
172
         0,                      /* bitpos */
173
         complain_overflow_bitfield, /* complain_on_overflow */
174
         cris_elf_pcrel_reloc,  /* special_function */
175
         "R_CRIS_8_PCREL",      /* name */
176
         FALSE,                 /* partial_inplace */
177
         0x0000,                /* src_mask */
178
         0x00ff,                /* dst_mask */
179
         TRUE),                 /* pcrel_offset */
180
 
181
  /* A 16 bit PC-relative relocation.  */
182
  HOWTO (R_CRIS_16_PCREL,       /* type */
183
         0,                      /* rightshift */
184
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
185
         16,                    /* bitsize */
186
         TRUE,                  /* pc_relative */
187
         0,                      /* bitpos */
188
         complain_overflow_bitfield, /* complain_on_overflow */
189
         cris_elf_pcrel_reloc,  /* special_function */
190
         "R_CRIS_16_PCREL",     /* name */
191
         FALSE,                 /* partial_inplace */
192
         0x00000000,            /* src_mask */
193
         0x0000ffff,            /* dst_mask */
194
         TRUE),                 /* pcrel_offset */
195
 
196
  /* A 32 bit PC-relative relocation.  */
197
  HOWTO (R_CRIS_32_PCREL,       /* type */
198
         0,                      /* rightshift */
199
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
200
         32,                    /* bitsize */
201
         TRUE,                  /* pc_relative */
202
         0,                      /* bitpos */
203
         complain_overflow_bitfield, /* complain_on_overflow */
204
         cris_elf_pcrel_reloc,  /* special_function */
205
         "R_CRIS_32_PCREL",     /* name */
206
         FALSE,                 /* partial_inplace */
207
         0x00000000,            /* src_mask */
208
         0xffffffff,            /* dst_mask */
209
         TRUE),                 /* pcrel_offset */
210
 
211
  /* GNU extension to record C++ vtable hierarchy.  */
212
  HOWTO (R_CRIS_GNU_VTINHERIT,  /* type */
213
         0,                      /* rightshift */
214
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
215
         0,                      /* bitsize */
216
         FALSE,                 /* pc_relative */
217
         0,                      /* bitpos */
218
         complain_overflow_dont, /* complain_on_overflow */
219
         NULL,                  /* special_function */
220
         "R_CRIS_GNU_VTINHERIT", /* name */
221
         FALSE,                 /* partial_inplace */
222
         0,                      /* src_mask */
223
         0,                      /* dst_mask */
224
         FALSE),                /* pcrel_offset */
225
 
226
  /* GNU extension to record C++ vtable member usage.  */
227
  HOWTO (R_CRIS_GNU_VTENTRY,    /* type */
228
         0,                      /* rightshift */
229
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
230
         0,                      /* bitsize */
231
         FALSE,                 /* pc_relative */
232
         0,                      /* bitpos */
233
         complain_overflow_dont, /* complain_on_overflow */
234
         _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
235
         "R_CRIS_GNU_VTENTRY",   /* name */
236
         FALSE,                 /* partial_inplace */
237
         0,                      /* src_mask */
238
         0,                      /* dst_mask */
239
         FALSE),                /* pcrel_offset */
240
 
241
  /* This is used only by the dynamic linker.  The symbol should exist
242
     both in the object being run and in some shared library.  The
243
     dynamic linker copies the data addressed by the symbol from the
244
     shared library into the object, because the object being
245
     run has to have the data at some particular address.  */
246
  HOWTO (R_CRIS_COPY,           /* type */
247
         0,                      /* rightshift */
248
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
249
         32,                    /* bitsize */
250
         FALSE,                 /* pc_relative */
251
         0,                      /* bitpos */
252
         complain_overflow_bitfield, /* complain_on_overflow */
253
         bfd_elf_generic_reloc, /* special_function */
254
         "R_CRIS_COPY",         /* name */
255
         FALSE,                 /* partial_inplace */
256
         0,                      /* src_mask */
257
         0,                      /* dst_mask */
258
         FALSE),                /* pcrel_offset */
259
 
260
  /* Like R_CRIS_32, but used when setting global offset table entries.  */
261
  HOWTO (R_CRIS_GLOB_DAT,       /* type */
262
         0,                      /* rightshift */
263
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
264
         32,                    /* bitsize */
265
         FALSE,                 /* pc_relative */
266
         0,                      /* bitpos */
267
         complain_overflow_bitfield, /* complain_on_overflow */
268
         bfd_elf_generic_reloc, /* special_function */
269
         "R_CRIS_GLOB_DAT",     /* name */
270
         FALSE,                 /* partial_inplace */
271
         0,                      /* src_mask */
272
         0xffffffff,            /* dst_mask */
273
         FALSE),                /* pcrel_offset */
274
 
275
  /* Marks a procedure linkage table entry for a symbol.  */
276
  HOWTO (R_CRIS_JUMP_SLOT,      /* type */
277
         0,                      /* rightshift */
278
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
279
         32,                    /* bitsize */
280
         FALSE,                 /* pc_relative */
281
         0,                      /* bitpos */
282
         complain_overflow_bitfield, /* complain_on_overflow */
283
         bfd_elf_generic_reloc, /* special_function */
284
         "R_CRIS_JUMP_SLOT",    /* name */
285
         FALSE,                 /* partial_inplace */
286
         0,                      /* src_mask */
287
         0,                      /* dst_mask */
288
         FALSE),                /* pcrel_offset */
289
 
290
  /* Used only by the dynamic linker.  When the object is run, this
291
     longword is set to the load address of the object, plus the
292
     addend.  */
293
  HOWTO (R_CRIS_RELATIVE,       /* type */
294
         0,                      /* rightshift */
295
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
296
         32,                    /* bitsize */
297
         FALSE,                 /* pc_relative */
298
         0,                      /* bitpos */
299
         complain_overflow_bitfield, /* complain_on_overflow */
300
         bfd_elf_generic_reloc, /* special_function */
301
         "R_CRIS_RELATIVE",     /* name */
302
         FALSE,                 /* partial_inplace */
303
         0,                      /* src_mask */
304
         0xffffffff,            /* dst_mask */
305
         FALSE),                /* pcrel_offset */
306
 
307
  /* Like R_CRIS_32, but referring to the GOT table entry for the symbol.  */
308
  HOWTO (R_CRIS_16_GOT,         /* type */
309
         0,                      /* rightshift */
310
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
311
         16,                    /* bitsize */
312
         FALSE,                 /* pc_relative */
313
         0,                      /* bitpos */
314
         complain_overflow_bitfield, /* complain_on_overflow */
315
         bfd_elf_generic_reloc, /* special_function */
316
         "R_CRIS_16_GOT",       /* name */
317
         FALSE,                 /* partial_inplace */
318
         0,                      /* src_mask */
319
         0xffff,                /* dst_mask */
320
         FALSE),                /* pcrel_offset */
321
 
322
  HOWTO (R_CRIS_32_GOT,         /* type */
323
         0,                      /* rightshift */
324
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
325
         32,                    /* bitsize */
326
         FALSE,                 /* pc_relative */
327
         0,                      /* bitpos */
328
         complain_overflow_bitfield, /* complain_on_overflow */
329
         bfd_elf_generic_reloc, /* special_function */
330
         "R_CRIS_32_GOT",       /* name */
331
         FALSE,                 /* partial_inplace */
332
         0,                      /* src_mask */
333
         0xffffffff,            /* dst_mask */
334
         FALSE),                /* pcrel_offset */
335
 
336
  /* Like R_CRIS_32_GOT, but referring to (and requesting a) PLT part of
337
     the GOT table for the symbol.  */
338
  HOWTO (R_CRIS_16_GOTPLT,      /* type */
339
         0,                      /* rightshift */
340
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
341
         16,                    /* bitsize */
342
         FALSE,                 /* pc_relative */
343
         0,                      /* bitpos */
344
         complain_overflow_bitfield, /* complain_on_overflow */
345
         bfd_elf_generic_reloc, /* special_function */
346
         "R_CRIS_16_GOTPLT",    /* name */
347
         FALSE,                 /* partial_inplace */
348
         0,                      /* src_mask */
349
         0xffff,                /* dst_mask */
350
         FALSE),                /* pcrel_offset */
351
 
352
  HOWTO (R_CRIS_32_GOTPLT,      /* type */
353
         0,                      /* rightshift */
354
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
355
         32,                    /* bitsize */
356
         FALSE,                 /* pc_relative */
357
         0,                      /* bitpos */
358
         complain_overflow_bitfield, /* complain_on_overflow */
359
         bfd_elf_generic_reloc, /* special_function */
360
         "R_CRIS_32_GOTPLT",    /* name */
361
         FALSE,                 /* partial_inplace */
362
         0,                      /* src_mask */
363
         0xffffffff,            /* dst_mask */
364
         FALSE),                /* pcrel_offset */
365
 
366
  /* A 32-bit offset from GOT to (local const) symbol: no GOT entry should
367
     be necessary.  */
368
  HOWTO (R_CRIS_32_GOTREL,      /* type */
369
         0,                      /* rightshift */
370
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
371
         32,                    /* bitsize */
372
         FALSE,                 /* pc_relative */
373
         0,                      /* bitpos */
374
         complain_overflow_bitfield, /* complain_on_overflow */
375
         bfd_elf_generic_reloc, /* special_function */
376
         "R_CRIS_32_GOTREL",    /* name */
377
         FALSE,                 /* partial_inplace */
378
         0,                      /* src_mask */
379
         0xffffffff,            /* dst_mask */
380
         FALSE),                /* pcrel_offset */
381
 
382
  /* A 32-bit offset from GOT to entry for this symbol in PLT and request
383
     to create PLT entry for symbol.  */
384
  HOWTO (R_CRIS_32_PLT_GOTREL,  /* type */
385
         0,                      /* rightshift */
386
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
387
         32,                    /* bitsize */
388
         FALSE,                 /* pc_relative */
389
         0,                      /* bitpos */
390
         complain_overflow_bitfield, /* complain_on_overflow */
391
         bfd_elf_generic_reloc, /* special_function */
392
         "R_CRIS_32_PLT_GOTREL", /* name */
393
         FALSE,                 /* partial_inplace */
394
         0,                      /* src_mask */
395
         0xffffffff,            /* dst_mask */
396
         FALSE),                /* pcrel_offset */
397
 
398
  /* A 32-bit offset from PC (location after the relocation) + addend to
399
     entry for this symbol in PLT and request to create PLT entry for
400
     symbol.  */
401
  HOWTO (R_CRIS_32_PLT_PCREL,   /* type */
402
         0,                      /* rightshift */
403
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
404
         32,                    /* bitsize */
405
         TRUE,                  /* pc_relative */
406
         0,                      /* bitpos */
407
         complain_overflow_bitfield, /* complain_on_overflow */
408
         cris_elf_pcrel_reloc,  /* special_function */
409
         "R_CRIS_32_PLT_PCREL", /* name */
410
         FALSE,                 /* partial_inplace */
411
         0,                      /* src_mask */
412
         0xffffffff,            /* dst_mask */
413
         TRUE),                 /* pcrel_offset */
414
 
415
  /* We don't handle these in any special manner and cross-format
416
     linking is not supported; just recognize them enough to pass them
417
     around.  FIXME: do the same for most PIC relocs and add sanity
418
     tests to actually refuse gracefully to handle these and PIC
419
     relocs for cross-format linking.  */
420
#define TLSHOWTO32(name) \
421
 HOWTO (name, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, \
422
        bfd_elf_generic_reloc, #name, FALSE, 0, 0xffffffff, FALSE)
423
#define TLSHOWTO16X(name, X)         \
424
 HOWTO (name, 0, 1, 16, FALSE, 0, complain_overflow_ ## X, \
425
        bfd_elf_generic_reloc, #name, FALSE, 0, 0xffff, FALSE)
426
#define TLSHOWTO16(name) TLSHOWTO16X(name, unsigned)
427
#define TLSHOWTO16S(name) TLSHOWTO16X(name, signed)
428
 
429
  TLSHOWTO32 (R_CRIS_32_GOT_GD),
430
  TLSHOWTO16 (R_CRIS_16_GOT_GD),
431
  TLSHOWTO32 (R_CRIS_32_GD),
432
  TLSHOWTO32 (R_CRIS_DTP),
433
  TLSHOWTO32 (R_CRIS_32_DTPREL),
434
  TLSHOWTO16S (R_CRIS_16_DTPREL),
435
  TLSHOWTO32 (R_CRIS_32_GOT_TPREL),
436
  TLSHOWTO16S (R_CRIS_16_GOT_TPREL),
437
  TLSHOWTO32 (R_CRIS_32_TPREL),
438
  TLSHOWTO16S (R_CRIS_16_TPREL),
439
  TLSHOWTO32 (R_CRIS_DTPMOD),
440
  TLSHOWTO32 (R_CRIS_32_IE)
441
};
442
 
443
/* Map BFD reloc types to CRIS ELF reloc types.  */
444
 
445
struct cris_reloc_map
446
{
447
  bfd_reloc_code_real_type bfd_reloc_val;
448
  unsigned int cris_reloc_val;
449
};
450
 
451
static const struct cris_reloc_map cris_reloc_map [] =
452
{
453
  { BFD_RELOC_NONE,             R_CRIS_NONE },
454
  { BFD_RELOC_8,                R_CRIS_8 },
455
  { BFD_RELOC_16,               R_CRIS_16 },
456
  { BFD_RELOC_32,               R_CRIS_32 },
457
  { BFD_RELOC_8_PCREL,          R_CRIS_8_PCREL },
458
  { BFD_RELOC_16_PCREL,         R_CRIS_16_PCREL },
459
  { BFD_RELOC_32_PCREL,         R_CRIS_32_PCREL },
460
  { BFD_RELOC_VTABLE_INHERIT,   R_CRIS_GNU_VTINHERIT },
461
  { BFD_RELOC_VTABLE_ENTRY,     R_CRIS_GNU_VTENTRY },
462
  { BFD_RELOC_CRIS_COPY,        R_CRIS_COPY },
463
  { BFD_RELOC_CRIS_GLOB_DAT,    R_CRIS_GLOB_DAT },
464
  { BFD_RELOC_CRIS_JUMP_SLOT,   R_CRIS_JUMP_SLOT },
465
  { BFD_RELOC_CRIS_RELATIVE,    R_CRIS_RELATIVE },
466
  { BFD_RELOC_CRIS_16_GOT,      R_CRIS_16_GOT },
467
  { BFD_RELOC_CRIS_32_GOT,      R_CRIS_32_GOT },
468
  { BFD_RELOC_CRIS_16_GOTPLT,   R_CRIS_16_GOTPLT },
469
  { BFD_RELOC_CRIS_32_GOTPLT,   R_CRIS_32_GOTPLT },
470
  { BFD_RELOC_CRIS_32_GOTREL,   R_CRIS_32_GOTREL },
471
  { BFD_RELOC_CRIS_32_PLT_GOTREL, R_CRIS_32_PLT_GOTREL },
472
  { BFD_RELOC_CRIS_32_PLT_PCREL, R_CRIS_32_PLT_PCREL },
473
  { BFD_RELOC_CRIS_32_GOT_GD,   R_CRIS_32_GOT_GD },
474
  { BFD_RELOC_CRIS_16_GOT_GD,   R_CRIS_16_GOT_GD },
475
  { BFD_RELOC_CRIS_32_GD,       R_CRIS_32_GD },
476
  { BFD_RELOC_CRIS_DTP, R_CRIS_DTP },
477
  { BFD_RELOC_CRIS_32_DTPREL,   R_CRIS_32_DTPREL },
478
  { BFD_RELOC_CRIS_16_DTPREL,   R_CRIS_16_DTPREL },
479
  { BFD_RELOC_CRIS_32_GOT_TPREL, R_CRIS_32_GOT_TPREL },
480
  { BFD_RELOC_CRIS_16_GOT_TPREL, R_CRIS_16_GOT_TPREL },
481
  { BFD_RELOC_CRIS_32_TPREL,    R_CRIS_32_TPREL },
482
  { BFD_RELOC_CRIS_16_TPREL,    R_CRIS_16_TPREL },
483
  { BFD_RELOC_CRIS_DTPMOD,      R_CRIS_DTPMOD },
484
  { BFD_RELOC_CRIS_32_IE,       R_CRIS_32_IE }
485
};
486
 
487
static reloc_howto_type *
488
cris_reloc_type_lookup (abfd, code)
489
     bfd * abfd ATTRIBUTE_UNUSED;
490
     bfd_reloc_code_real_type code;
491
{
492
  unsigned int i;
493
 
494
  for (i = 0; i < sizeof (cris_reloc_map) / sizeof (cris_reloc_map[0]); i++)
495
    if (cris_reloc_map [i].bfd_reloc_val == code)
496
      return & cris_elf_howto_table [cris_reloc_map[i].cris_reloc_val];
497
 
498
  return NULL;
499
}
500
 
501
static reloc_howto_type *
502
cris_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
503
{
504
  unsigned int i;
505
 
506
  for (i = 0;
507
       i < sizeof (cris_elf_howto_table) / sizeof (cris_elf_howto_table[0]);
508
       i++)
509
    if (cris_elf_howto_table[i].name != NULL
510
        && strcasecmp (cris_elf_howto_table[i].name, r_name) == 0)
511
      return &cris_elf_howto_table[i];
512
 
513
  return NULL;
514
}
515
 
516
/* Set the howto pointer for an CRIS ELF reloc.  */
517
 
518
static void
519
cris_info_to_howto_rela (abfd, cache_ptr, dst)
520
     bfd * abfd ATTRIBUTE_UNUSED;
521
     arelent * cache_ptr;
522
     Elf_Internal_Rela * dst;
523
{
524
  enum elf_cris_reloc_type r_type;
525
 
526
  r_type = ELF32_R_TYPE (dst->r_info);
527
  BFD_ASSERT (r_type < (unsigned int) R_CRIS_max);
528
  cache_ptr->howto = & cris_elf_howto_table [r_type];
529
}
530
 
531
bfd_reloc_status_type
532
cris_elf_pcrel_reloc (abfd, reloc_entry, symbol, data, input_section,
533
                      output_bfd, error_message)
534
     bfd *abfd ATTRIBUTE_UNUSED;
535
     arelent *reloc_entry;
536
     asymbol *symbol;
537
     PTR data ATTRIBUTE_UNUSED;
538
     asection *input_section;
539
     bfd *output_bfd;
540
     char **error_message ATTRIBUTE_UNUSED;
541
{
542
  /* By default (using only bfd_elf_generic_reloc when linking to
543
     non-ELF formats) PC-relative relocs are relative to the beginning
544
     of the reloc.  CRIS PC-relative relocs are relative to the position
545
     *after* the reloc because that's what pre-CRISv32 PC points to
546
     after reading an insn field with that reloc.  (For CRISv32, PC is
547
     actually relative to the start of the insn, but we keep the old
548
     definition.)  Still, we use as much generic machinery as we can.
549
 
550
     Only adjust when doing a final link.  */
551
  if (output_bfd == (bfd *) NULL)
552
    reloc_entry->addend -= 1 << reloc_entry->howto->size;
553
 
554
  return
555
    bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
556
                           input_section, output_bfd, error_message);
557
}
558
 
559
/* Support for core dump NOTE sections.
560
   The slightly unintuitive code layout is an attempt to keep at least
561
   some similarities with other ports, hoping to simplify general
562
   changes, while still keeping Linux/CRIS and Linux/CRISv32 code apart.  */
563
 
564
static bfd_boolean
565
cris_elf_grok_prstatus (abfd, note)
566
     bfd *abfd;
567
     Elf_Internal_Note *note;
568
{
569
  int offset;
570
  size_t size;
571
 
572
  if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
573
    switch (note->descsz)
574
      {
575
      default:
576
        return FALSE;
577
 
578
      case 202:         /* Linux/CRISv32 */
579
        /* pr_cursig */
580
        elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
581
 
582
        /* pr_pid */
583
        elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 22);
584
 
585
        /* pr_reg */
586
        offset = 70;
587
        size = 128;
588
 
589
        break;
590
      }
591
  else
592
    switch (note->descsz)
593
      {
594
      default:
595
        return FALSE;
596
 
597
      case 214:         /* Linux/CRIS */
598
        /* pr_cursig */
599
        elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
600
 
601
        /* pr_pid */
602
        elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 22);
603
 
604
        /* pr_reg */
605
        offset = 70;
606
        size = 140;
607
 
608
        break;
609
      }
610
 
611
  /* Make a ".reg/999" section.  */
612
  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
613
                                          size, note->descpos + offset);
614
}
615
 
616
static bfd_boolean
617
cris_elf_grok_psinfo (abfd, note)
618
     bfd *abfd;
619
     Elf_Internal_Note *note;
620
{
621
  if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
622
    switch (note->descsz)
623
      {
624
      default:
625
        return FALSE;
626
 
627
      case 124:         /* Linux/CRISv32 elf_prpsinfo */
628
        elf_tdata (abfd)->core_program
629
          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
630
        elf_tdata (abfd)->core_command
631
          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
632
      }
633
  else
634
    switch (note->descsz)
635
      {
636
      default:
637
        return FALSE;
638
 
639
      case 124:         /* Linux/CRIS elf_prpsinfo */
640
        elf_tdata (abfd)->core_program
641
          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
642
        elf_tdata (abfd)->core_command
643
          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
644
      }
645
 
646
  /* Note that for some reason, a spurious space is tacked
647
     onto the end of the args in some (at least one anyway)
648
     implementations, so strip it off if it exists.  */
649
 
650
  {
651
    char *command = elf_tdata (abfd)->core_command;
652
    int n = strlen (command);
653
 
654
    if (0 < n && command[n - 1] == ' ')
655
      command[n - 1] = '\0';
656
  }
657
 
658
  return TRUE;
659
}
660
 
661
/* The name of the dynamic interpreter.  This is put in the .interp
662
   section.  */
663
 
664
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
665
 
666
/* The size in bytes of an entry in the procedure linkage table.  */
667
 
668
#define PLT_ENTRY_SIZE 20
669
#define PLT_ENTRY_SIZE_V32 26
670
 
671
/* The first entry in an absolute procedure linkage table looks like this.  */
672
 
673
static const bfd_byte elf_cris_plt0_entry[PLT_ENTRY_SIZE] =
674
{
675
  0xfc, 0xe1,
676
  0x7e, 0x7e,   /* push mof.  */
677
  0x7f, 0x0d,   /*  (dip [pc+]) */
678
  0, 0, 0, 0,       /*  Replaced with address of .got + 4.  */
679
  0x30, 0x7a,   /* move [...],mof */
680
  0x7f, 0x0d,   /*  (dip [pc+]) */
681
  0, 0, 0, 0,       /*  Replaced with address of .got + 8.  */
682
  0x30, 0x09    /* jump [...] */
683
};
684
 
685
static const bfd_byte elf_cris_plt0_entry_v32[PLT_ENTRY_SIZE_V32] =
686
{
687
  0x84, 0xe2,   /* subq 4,$sp */
688
  0x6f, 0xfe,   /* move.d 0,$acr */
689
  0, 0, 0, 0,       /*  Replaced by address of .got + 4.  */
690
  0x7e, 0x7a,   /* move $mof,[$sp] */
691
  0x3f, 0x7a,   /* move [$acr],$mof */
692
  0x04, 0xf2,   /* addq 4,acr */
693
  0x6f, 0xfa,   /* move.d [$acr],$acr */
694
  0xbf, 0x09,   /* jump $acr */
695
  0xb0, 0x05,   /* nop */
696
  0, 0            /*  Pad out to 26 bytes.  */
697
};
698
 
699
/* Subsequent entries in an absolute procedure linkage table look like
700
   this.  */
701
 
702
static const bfd_byte elf_cris_plt_entry[PLT_ENTRY_SIZE] =
703
{
704
  0x7f, 0x0d,   /*  (dip [pc+]) */
705
  0, 0, 0, 0,       /*  Replaced with address of this symbol in .got.  */
706
  0x30, 0x09,   /* jump [...] */
707
  0x3f,  0x7e,  /* move [pc+],mof */
708
  0, 0, 0, 0,       /*  Replaced with offset into relocation table.  */
709
  0x2f, 0xfe,   /* add.d [pc+],pc */
710
  0xec, 0xff,
711
  0xff, 0xff    /*  Replaced with offset to start of .plt.  */
712
};
713
 
714
static const bfd_byte elf_cris_plt_entry_v32[PLT_ENTRY_SIZE_V32] =
715
{
716
  0x6f, 0xfe,   /* move.d 0,$acr */
717
  0, 0, 0, 0,       /*  Replaced with address of this symbol in .got.  */
718
  0x6f, 0xfa,   /* move.d [$acr],$acr */
719
  0xbf, 0x09,   /* jump $acr */
720
  0xb0, 0x05,   /* nop */
721
  0x3f, 0x7e,   /* move 0,mof */
722
  0, 0, 0, 0,       /*  Replaced with offset into relocation table. */
723
  0xbf, 0x0e,   /* ba start_of_plt0_entry */
724
  0, 0, 0, 0,       /*  Replaced with offset to plt0 entry.  */
725
  0xb0, 0x05    /* nop */
726
};
727
 
728
/* The first entry in a PIC procedure linkage table looks like this.  */
729
 
730
static const bfd_byte elf_cris_pic_plt0_entry[PLT_ENTRY_SIZE] =
731
{
732
  0xfc, 0xe1, 0x7e, 0x7e,       /* push mof */
733
  0x04, 0x01, 0x30, 0x7a,       /* move [r0+4],mof */
734
  0x08, 0x01, 0x30, 0x09,       /* jump [r0+8] */
735
  0, 0, 0, 0, 0, 0, 0, 0,       /*  Pad out to 20 bytes.  */
736
};
737
 
738
static const bfd_byte elf_cris_pic_plt0_entry_v32[PLT_ENTRY_SIZE_V32] =
739
{
740
  0x84, 0xe2,   /* subq 4,$sp */
741
  0x04, 0x01,   /* addoq 4,$r0,$acr */
742
  0x7e, 0x7a,   /* move $mof,[$sp] */
743
  0x3f, 0x7a,   /* move [$acr],$mof */
744
  0x04, 0xf2,   /* addq 4,$acr */
745
  0x6f, 0xfa,   /* move.d [$acr],$acr */
746
  0xbf, 0x09,   /* jump $acr */
747
  0xb0, 0x05,   /* nop */
748
  0, 0,           /*  Pad out to 26 bytes.  */
749
  0, 0, 0, 0,
750
  0, 0, 0, 0
751
};
752
 
753
/* Subsequent entries in a PIC procedure linkage table look like this.  */
754
 
755
static const bfd_byte elf_cris_pic_plt_entry[PLT_ENTRY_SIZE] =
756
{
757
  0x6f, 0x0d,   /*  (bdap [pc+].d,r0) */
758
  0, 0, 0, 0,       /*  Replaced with offset of this symbol in .got.  */
759
  0x30, 0x09,   /* jump [...] */
760
  0x3f, 0x7e,   /* move [pc+],mof */
761
  0, 0, 0, 0,       /*  Replaced with offset into relocation table.  */
762
  0x2f, 0xfe,   /* add.d [pc+],pc */
763
  0xec, 0xff,   /*  Replaced with offset to start of .plt.  */
764
  0xff, 0xff
765
};
766
 
767
static const bfd_byte elf_cris_pic_plt_entry_v32[PLT_ENTRY_SIZE_V32] =
768
{
769
  0x6f, 0x0d,   /* addo.d 0,$r0,$acr */
770
  0, 0, 0, 0,       /*  Replaced with offset of this symbol in .got.  */
771
  0x6f, 0xfa,   /* move.d [$acr],$acr */
772
  0xbf, 0x09,   /* jump $acr */
773
  0xb0, 0x05,   /* nop */
774
  0x3f, 0x7e,   /* move relocoffs,$mof */
775
  0, 0, 0, 0,       /*  Replaced with offset into relocation table.  */
776
  0xbf, 0x0e,   /* ba start_of_plt */
777
  0, 0, 0, 0,       /*  Replaced with offset to start of .plt.  */
778
  0xb0, 0x05    /* nop */
779
};
780
 
781
/* We copy elf32-m68k.c and elf32-i386.c for the basic linker hash bits
782
   (and most other PIC/shlib stuff).  Check that we don't drift away
783
   without reason.
784
 
785
   The CRIS linker, like the m68k and i386 linkers (and probably the rest
786
   too) needs to keep track of the number of relocs that it decides to
787
   copy in check_relocs for each symbol.  This is so that it can discard
788
   PC relative relocs if it doesn't need them when linking with
789
   -Bsymbolic.  We store the information in a field extending the regular
790
   ELF linker hash table.  */
791
 
792
/* This structure keeps track of the number of PC relative relocs we have
793
   copied for a given symbol.  */
794
 
795
struct elf_cris_pcrel_relocs_copied
796
{
797
  /* Next section.  */
798
  struct elf_cris_pcrel_relocs_copied *next;
799
 
800
  /* A section in dynobj.  */
801
  asection *section;
802
 
803
  /* Number of relocs copied in this section.  */
804
  bfd_size_type count;
805
 
806
  /* Example of reloc being copied, for message.  */
807
  enum elf_cris_reloc_type r_type;
808
};
809
 
810
/* CRIS ELF linker hash entry.  */
811
 
812
struct elf_cris_link_hash_entry
813
{
814
  struct elf_link_hash_entry root;
815
 
816
  /* Number of PC relative relocs copied for this symbol.  */
817
  struct elf_cris_pcrel_relocs_copied *pcrel_relocs_copied;
818
 
819
  /* The GOTPLT references are CRIS-specific; the goal is to avoid having
820
     both a general GOT and a PLT-specific GOT entry for the same symbol,
821
     when it is referenced both as a function and as a function pointer.
822
 
823
     Number of GOTPLT references for a function.  */
824
  bfd_signed_vma gotplt_refcount;
825
 
826
  /* Actual GOTPLT index for this symbol, if applicable, or zero if not
827
     (zero is never used as an index).  FIXME: We should be able to fold
828
     this with gotplt_refcount in a union, like the got and plt unions in
829
     elf_link_hash_entry.  */
830
  bfd_size_type gotplt_offset;
831
 
832
  /* The root.got.refcount is the sum of the regular reference counts
833
     (this) and those members below.  We have to keep a separate count
834
     to track when we've found the first (or last) reference to a
835
     regular got entry.  The offset is in root.got.offset.  */
836
  bfd_signed_vma reg_got_refcount;
837
 
838
  /* Similar to the above, the number of reloc references to this
839
     symbols that need a R_CRIS_32_TPREL slot.  The offset is in
840
     root.got.offset, because this and .dtp_refcount can't validly
841
     happen when there's also a regular GOT entry; that's invalid
842
     input for which an error is emitted.  */
843
  bfd_signed_vma tprel_refcount;
844
 
845
  /* Similar to the above, the number of reloc references to this
846
     symbols that need a R_CRIS_DTP slot.  The offset is in
847
     root.got.offset; plus 4 if .tprel_refcount > 0.  */
848
  bfd_signed_vma dtp_refcount;
849
};
850
 
851
/* The local_got_refcounts and local_got_offsets are a multiple of
852
   LSNUM in size, namely LGOT_ALLOC_NELTS_FOR(LSNUM) (plus one for the
853
   refcount for GOT itself, see code), with the summary / group offset
854
   for local symbols located at offset N, reference counts for
855
   ordinary (address) relocs at offset N + LSNUM, for R_CRIS_DTP
856
   relocs at offset N + 2*LSNUM, and for R_CRIS_32_TPREL relocs at N +
857
   3*LSNUM.  */
858
 
859
#define LGOT_REG_NDX(x) ((x) + symtab_hdr->sh_info)
860
#define LGOT_DTP_NDX(x) ((x) + 2 * symtab_hdr->sh_info)
861
#define LGOT_TPREL_NDX(x) ((x) + 3 * symtab_hdr->sh_info)
862
#define LGOT_ALLOC_NELTS_FOR(x) ((x) * 4)
863
 
864
/* CRIS ELF linker hash table.  */
865
 
866
struct elf_cris_link_hash_table
867
{
868
  struct elf_link_hash_table root;
869
 
870
  /* We can't use the PLT offset and calculate to get the GOTPLT offset,
871
     since we try and avoid creating GOTPLT:s when there's already a GOT.
872
     Instead, we keep and update the next available index here.  */
873
  bfd_size_type next_gotplt_entry;
874
 
875
  /* The number of R_CRIS_32_DTPREL and R_CRIS_16_DTPREL that have
876
     been seen for any input; if != 0, then the constant-offset
877
     R_CRIS_DTPMOD is needed for this DSO/executable.  This turns
878
     negative at relocation, so that we don't need an extra flag for
879
     when the reloc is output.  */
880
  bfd_signed_vma dtpmod_refcount;
881
};
882
 
883
/* Traverse a CRIS ELF linker hash table.  */
884
 
885
#define elf_cris_link_hash_traverse(table, func, info)                  \
886
  (elf_link_hash_traverse                                               \
887
   (&(table)->root,                                                     \
888
    (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
889
    (info)))
890
 
891
/* Get the CRIS ELF linker hash table from a link_info structure.  */
892
 
893
#define elf_cris_hash_table(p) \
894
  (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
895
  == CRIS_ELF_DATA ? ((struct elf_cris_link_hash_table *) ((p)->hash)) : NULL)
896
 
897
/* Get the CRIS ELF linker hash entry from a regular hash entry (the
898
   "parent class").  The .root reference is just a simple type
899
   check on the argument.  */
900
 
901
#define elf_cris_hash_entry(p) \
902
 ((struct elf_cris_link_hash_entry *) (&(p)->root))
903
 
904
/* Create an entry in a CRIS ELF linker hash table.  */
905
 
906
static struct bfd_hash_entry *
907
elf_cris_link_hash_newfunc (struct bfd_hash_entry *entry,
908
                            struct bfd_hash_table *table,
909
                            const char *string)
910
{
911
  struct elf_cris_link_hash_entry *ret =
912
    (struct elf_cris_link_hash_entry *) entry;
913
 
914
  /* Allocate the structure if it has not already been allocated by a
915
     subclass.  */
916
  if (ret == (struct elf_cris_link_hash_entry *) NULL)
917
    ret = ((struct elf_cris_link_hash_entry *)
918
           bfd_hash_allocate (table,
919
                              sizeof (struct elf_cris_link_hash_entry)));
920
  if (ret == (struct elf_cris_link_hash_entry *) NULL)
921
    return (struct bfd_hash_entry *) ret;
922
 
923
  /* Call the allocation method of the superclass.  */
924
  ret = ((struct elf_cris_link_hash_entry *)
925
         _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
926
                                     table, string));
927
  if (ret != (struct elf_cris_link_hash_entry *) NULL)
928
    {
929
      ret->pcrel_relocs_copied = NULL;
930
      ret->gotplt_refcount = 0;
931
      ret->gotplt_offset = 0;
932
      ret->dtp_refcount = 0;
933
      ret->tprel_refcount = 0;
934
      ret->reg_got_refcount = 0;
935
    }
936
 
937
  return (struct bfd_hash_entry *) ret;
938
}
939
 
940
/* Create a CRIS ELF linker hash table.  */
941
 
942
static struct bfd_link_hash_table *
943
elf_cris_link_hash_table_create (bfd *abfd)
944
{
945
  struct elf_cris_link_hash_table *ret;
946
  bfd_size_type amt = sizeof (struct elf_cris_link_hash_table);
947
 
948
  ret = ((struct elf_cris_link_hash_table *) bfd_malloc (amt));
949
  if (ret == (struct elf_cris_link_hash_table *) NULL)
950
    return NULL;
951
 
952
  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
953
                                      elf_cris_link_hash_newfunc,
954
                                      sizeof (struct elf_cris_link_hash_entry),
955
                                      CRIS_ELF_DATA))
956
    {
957
      free (ret);
958
      return NULL;
959
    }
960
 
961
  /* Initialize to skip over the first three entries in the gotplt; they
962
     are used for run-time symbol evaluation.  */
963
  ret->next_gotplt_entry = 12;
964
 
965
  /* We haven't seen any R_CRIS_nn_GOT_TPREL initially.  */
966
  ret->dtpmod_refcount = 0;
967
 
968
  return &ret->root.root;
969
}
970
 
971
/* Perform a single relocation.  By default we use the standard BFD
972
   routines, with a few tweaks.  */
973
 
974
static bfd_reloc_status_type
975
cris_final_link_relocate (howto, input_bfd, input_section, contents, rel,
976
                          relocation)
977
     reloc_howto_type *  howto;
978
     bfd *               input_bfd;
979
     asection *          input_section;
980
     bfd_byte *          contents;
981
     Elf_Internal_Rela * rel;
982
     bfd_vma             relocation;
983
{
984
  bfd_reloc_status_type r;
985
  enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rel->r_info);
986
 
987
  /* PC-relative relocations are relative to the position *after*
988
     the reloc.  Note that for R_CRIS_8_PCREL the adjustment is
989
     not a single byte, since PC must be 16-bit-aligned.  */
990
  switch (r_type)
991
    {
992
      /* Check that the 16-bit GOT relocs are positive.  */
993
    case R_CRIS_16_GOTPLT:
994
    case R_CRIS_16_GOT:
995
      if ((bfd_signed_vma) relocation < 0)
996
        return bfd_reloc_overflow;
997
      break;
998
 
999
    case R_CRIS_32_PLT_PCREL:
1000
    case R_CRIS_32_PCREL:
1001
      relocation -= 2;
1002
      /* Fall through.  */
1003
    case R_CRIS_8_PCREL:
1004
    case R_CRIS_16_PCREL:
1005
      relocation -= 2;
1006
      break;
1007
 
1008
    default:
1009
      break;
1010
    }
1011
 
1012
  r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1013
                                contents, rel->r_offset,
1014
                                relocation, rel->r_addend);
1015
  return r;
1016
}
1017
 
1018
 
1019
/* The number of errors left before we stop outputting reloc-specific
1020
   explanatory messages.  By coincidence, this works nicely together
1021
   with the default number of messages you'll get from LD about
1022
   "relocation truncated to fit" messages before you get an
1023
   "additional relocation overflows omitted from the output".  */
1024
static int additional_relocation_error_msg_count = 10;
1025
 
1026
/* Relocate an CRIS ELF section.  See elf32-fr30.c, from where this was
1027
   copied, for further comments.  */
1028
 
1029
static bfd_boolean
1030
cris_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1031
                           struct bfd_link_info *info,
1032
                           bfd *input_bfd,
1033
                           asection *input_section,
1034
                           bfd_byte *contents,
1035
                           Elf_Internal_Rela *relocs,
1036
                           Elf_Internal_Sym *local_syms,
1037
                           asection **local_sections)
1038
{
1039
  struct elf_cris_link_hash_table * htab;
1040
  bfd *dynobj;
1041
  Elf_Internal_Shdr *symtab_hdr;
1042
  struct elf_link_hash_entry **sym_hashes;
1043
  bfd_vma *local_got_offsets;
1044
  asection *sgot;
1045
  asection *splt;
1046
  asection *sreloc;
1047
  Elf_Internal_Rela *rel;
1048
  Elf_Internal_Rela *relend;
1049
  asection *srelgot;
1050
 
1051
  htab = elf_cris_hash_table (info);
1052
  if (htab == NULL)
1053
    return FALSE;
1054
 
1055
  dynobj = elf_hash_table (info)->dynobj;
1056
  local_got_offsets = elf_local_got_offsets (input_bfd);
1057
  symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1058
  sym_hashes = elf_sym_hashes (input_bfd);
1059
  relend     = relocs + input_section->reloc_count;
1060
 
1061
  sgot = NULL;
1062
  splt = NULL;
1063
  sreloc = NULL;
1064
  srelgot = NULL;
1065
 
1066
  if (dynobj != NULL)
1067
    {
1068
      splt = bfd_get_section_by_name (dynobj, ".plt");
1069
      sgot = bfd_get_section_by_name (dynobj, ".got");
1070
    }
1071
 
1072
  for (rel = relocs; rel < relend; rel ++)
1073
    {
1074
      reloc_howto_type *howto;
1075
      unsigned long r_symndx;
1076
      Elf_Internal_Sym *sym;
1077
      asection *sec;
1078
      struct elf_link_hash_entry *h;
1079
      bfd_vma relocation;
1080
      bfd_reloc_status_type r;
1081
      const char *symname = NULL;
1082
      enum elf_cris_reloc_type r_type;
1083
 
1084
      r_type = ELF32_R_TYPE (rel->r_info);
1085
 
1086
      if (   r_type == R_CRIS_GNU_VTINHERIT
1087
          || r_type == R_CRIS_GNU_VTENTRY)
1088
        continue;
1089
 
1090
      r_symndx = ELF32_R_SYM (rel->r_info);
1091
      howto  = cris_elf_howto_table + r_type;
1092
      h      = NULL;
1093
      sym    = NULL;
1094
      sec    = NULL;
1095
 
1096
      if (r_symndx < symtab_hdr->sh_info)
1097
        {
1098
          sym = local_syms + r_symndx;
1099
          sec = local_sections [r_symndx];
1100
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1101
 
1102
          symname = (bfd_elf_string_from_elf_section
1103
                     (input_bfd, symtab_hdr->sh_link, sym->st_name));
1104
          if (symname == NULL)
1105
            symname = bfd_section_name (input_bfd, sec);
1106
        }
1107
      else
1108
        {
1109
          bfd_boolean warned;
1110
          bfd_boolean unresolved_reloc;
1111
 
1112
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1113
                                   r_symndx, symtab_hdr, sym_hashes,
1114
                                   h, sec, relocation,
1115
                                   unresolved_reloc, warned);
1116
 
1117
          symname = h->root.root.string;
1118
 
1119
          if (unresolved_reloc
1120
              /* Perhaps we should detect the cases that
1121
                 sec->output_section is expected to be NULL like i386 and
1122
                 m68k, but apparently (and according to elfxx-ia64.c) all
1123
                 valid cases are where the symbol is defined in a shared
1124
                 object which we link dynamically against.  This includes
1125
                 PLT relocs for which we've created a PLT entry and other
1126
                 relocs for which we're prepared to create dynamic
1127
                 relocations.
1128
 
1129
                 For now, new situations cause us to just err when
1130
                 sec->output_offset is NULL but the object with the symbol
1131
                 is *not* dynamically linked against.  Thus this will
1132
                 automatically remind us so we can see if there are other
1133
                 valid cases we need to revisit.  */
1134
              && (sec->owner->flags & DYNAMIC) != 0)
1135
            relocation = 0;
1136
 
1137
          else if (h->root.type == bfd_link_hash_defined
1138
                   || h->root.type == bfd_link_hash_defweak)
1139
            {
1140
              /* Here follow the cases where the relocation value must
1141
                 be zero (or when further handling is simplified when
1142
                 zero).  I can't claim to understand the various
1143
                 conditions and they weren't described in the files
1144
                 where I copied them from (elf32-m68k.c and
1145
                 elf32-i386.c), but let's mention examples of where
1146
                 they happen.  FIXME: Perhaps define and use a
1147
                 dynamic_symbol_p function like ia64.
1148
 
1149
                 - When creating a shared library, we can have an
1150
                 ordinary relocation for a symbol defined in a shared
1151
                 library (perhaps the one we create).  We then make
1152
                 the relocation value zero, as the value seen now will
1153
                 be added into the relocation addend in this shared
1154
                 library, but must be handled only at dynamic-link
1155
                 time.  FIXME: Not sure this example covers the
1156
                 h->elf_link_hash_flags test, though it's there in
1157
                 other targets.  */
1158
              if (info->shared
1159
                  && ((! info->symbolic && h->dynindx != -1)
1160
                      || !h->def_regular)
1161
                  && (input_section->flags & SEC_ALLOC) != 0
1162
                  && (r_type == R_CRIS_8
1163
                      || r_type == R_CRIS_16
1164
                      || r_type == R_CRIS_32
1165
                      || r_type == R_CRIS_8_PCREL
1166
                      || r_type == R_CRIS_16_PCREL
1167
                      || r_type == R_CRIS_32_PCREL))
1168
                relocation = 0;
1169
              else if (!info->relocatable && unresolved_reloc)
1170
                {
1171
                  _bfd_error_handler
1172
                    (_("%B, section %A: unresolvable relocation %s against symbol `%s'"),
1173
                     input_bfd,
1174
                     input_section,
1175
                     cris_elf_howto_table[r_type].name,
1176
                     symname);
1177
                  bfd_set_error (bfd_error_bad_value);
1178
                  return FALSE;
1179
                }
1180
            }
1181
        }
1182
 
1183
      if (sec != NULL && elf_discarded_section (sec))
1184
        {
1185
          /* For relocs against symbols from removed linkonce sections,
1186
             or sections discarded by a linker script, we just want the
1187
             section contents zeroed.  Avoid any special processing.  */
1188
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1189
          rel->r_info = 0;
1190
          rel->r_addend = 0;
1191
          continue;
1192
        }
1193
 
1194
      if (info->relocatable)
1195
        continue;
1196
 
1197
      switch (r_type)
1198
        {
1199
        case R_CRIS_16_GOTPLT:
1200
        case R_CRIS_32_GOTPLT:
1201
          /* This is like the case for R_CRIS_32_GOT and R_CRIS_16_GOT,
1202
             but we require a PLT, and the PLT handling will take care of
1203
             filling in the PLT-specific GOT entry.  For the GOT offset,
1204
             calculate it as we do when filling it in for the .got.plt
1205
             section.  If we don't have a PLT, punt to GOT handling.  */
1206
          if (h != NULL
1207
              && ((struct elf_cris_link_hash_entry *) h)->gotplt_offset != 0)
1208
            {
1209
              asection *sgotplt
1210
                = bfd_get_section_by_name (dynobj, ".got.plt");
1211
              bfd_vma got_offset;
1212
 
1213
              BFD_ASSERT (h->dynindx != -1);
1214
              BFD_ASSERT (sgotplt != NULL);
1215
 
1216
              got_offset
1217
                = ((struct elf_cris_link_hash_entry *) h)->gotplt_offset;
1218
 
1219
              relocation = got_offset;
1220
              break;
1221
            }
1222
 
1223
          /* We didn't make a PLT entry for this symbol.  Maybe everything is
1224
             folded into the GOT.  Other than folding, this happens when
1225
             statically linking PIC code, or when using -Bsymbolic.  Check
1226
             that we instead have a GOT entry as done for us by
1227
             elf_cris_adjust_dynamic_symbol, and drop through into the
1228
             ordinary GOT cases.  This must not happen for the
1229
             executable, because any reference it does to a function
1230
             that is satisfied by a DSO must generate a PLT.  We assume
1231
             these call-specific relocs don't address non-functions.  */
1232
          if (h != NULL
1233
              && (h->got.offset == (bfd_vma) -1
1234
                  || (!info->shared
1235
                      && !(h->def_regular
1236
                           || (!h->def_dynamic
1237
                               && h->root.type == bfd_link_hash_undefweak)))))
1238
            {
1239
              (*_bfd_error_handler)
1240
                ((h->got.offset == (bfd_vma) -1)
1241
                 ? _("%B, section %A: No PLT nor GOT for relocation %s"
1242
                     " against symbol `%s'")
1243
                 : _("%B, section %A: No PLT for relocation %s"
1244
                     " against symbol `%s'"),
1245
                 input_bfd,
1246
                 input_section,
1247
                 cris_elf_howto_table[r_type].name,
1248
                 (symname != NULL && symname[0] != '\0'
1249
                  ? symname : _("[whose name is lost]")));
1250
 
1251
              /* FIXME: Perhaps blaming input is not the right thing to
1252
                 do; this is probably an internal error.  But it is true
1253
                 that we didn't like that particular input.  */
1254
              bfd_set_error (bfd_error_bad_value);
1255
              return FALSE;
1256
            }
1257
          /* Fall through.  */
1258
 
1259
          /* The size of the actual relocation is not used here; we only
1260
             fill in the GOT table here.  */
1261
        case R_CRIS_16_GOT:
1262
        case R_CRIS_32_GOT:
1263
          {
1264
            bfd_vma off;
1265
 
1266
            /* Note that despite using RELA relocations, the .got contents
1267
               is always filled in with the link-relative relocation
1268
               value; the addend.  */
1269
 
1270
            if (h != NULL)
1271
              {
1272
                off = h->got.offset;
1273
                BFD_ASSERT (off != (bfd_vma) -1);
1274
 
1275
                if (!elf_hash_table (info)->dynamic_sections_created
1276
                    || (! info->shared
1277
                        && (h->def_regular
1278
                            || h->type == STT_FUNC
1279
                            || h->needs_plt))
1280
                    || (info->shared
1281
                        && (info->symbolic || h->dynindx == -1)
1282
                        && h->def_regular))
1283
                  {
1284
                    /* This wasn't checked above for ! info->shared, but
1285
                       must hold there if we get here; the symbol must
1286
                       be defined in the regular program or be undefweak
1287
                       or be a function or otherwise need a PLT.  */
1288
                    BFD_ASSERT (!elf_hash_table (info)->dynamic_sections_created
1289
                                || info->shared
1290
                                || h->def_regular
1291
                                || h->type == STT_FUNC
1292
                                || h->needs_plt
1293
                                || h->root.type == bfd_link_hash_undefweak);
1294
 
1295
                    /* This is actually a static link, or it is a
1296
                       -Bsymbolic link and the symbol is defined locally,
1297
                       or is undefweak, or the symbol was forced to be
1298
                       local because of a version file, or we're not
1299
                       creating a dynamic object.  We must initialize this
1300
                       entry in the global offset table.  Since the offset
1301
                       must always be a multiple of 4, we use the least
1302
                       significant bit to record whether we have
1303
                       initialized it already.
1304
 
1305
                       If this GOT entry should be runtime-initialized, we
1306
                       will create a .rela.got relocation entry to
1307
                       initialize the value.  This is done in the
1308
                       finish_dynamic_symbol routine.  */
1309
                    if ((off & 1) != 0)
1310
                      off &= ~1;
1311
                    else
1312
                      {
1313
                        bfd_put_32 (output_bfd, relocation,
1314
                                    sgot->contents + off);
1315
                        h->got.offset |= 1;
1316
                      }
1317
                  }
1318
              }
1319
            else
1320
              {
1321
                BFD_ASSERT (local_got_offsets != NULL
1322
                            && local_got_offsets[r_symndx] != (bfd_vma) -1);
1323
 
1324
                off = local_got_offsets[r_symndx];
1325
 
1326
                /* The offset must always be a multiple of 4.  We use
1327
                   the least significant bit to record whether we have
1328
                   already generated the necessary reloc.  */
1329
                if ((off & 1) != 0)
1330
                  off &= ~1;
1331
                else
1332
                  {
1333
                    bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1334
 
1335
                    if (info->shared)
1336
                      {
1337
                        Elf_Internal_Rela outrel;
1338
                        bfd_byte *loc;
1339
 
1340
                        if (srelgot == NULL)
1341
                          srelgot
1342
                            = bfd_get_section_by_name (dynobj, ".rela.got");
1343
                        BFD_ASSERT (srelgot != NULL);
1344
 
1345
                        outrel.r_offset = (sgot->output_section->vma
1346
                                           + sgot->output_offset
1347
                                           + off);
1348
                        outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1349
                        outrel.r_addend = relocation;
1350
                        loc = srelgot->contents;
1351
                        loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1352
                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1353
                      }
1354
 
1355
                    local_got_offsets[r_symndx] |= 1;
1356
                  }
1357
              }
1358
 
1359
            relocation = sgot->output_offset + off;
1360
            if (rel->r_addend != 0)
1361
              {
1362
                /* We can't do anything for a relocation which is against
1363
                   a symbol *plus offset*.  GOT holds relocations for
1364
                   symbols.  Make this an error; the compiler isn't
1365
                   allowed to pass us these kinds of things.  */
1366
                if (h == NULL)
1367
                  (*_bfd_error_handler)
1368
                    (_("%B, section %A: relocation %s with non-zero addend %d"
1369
                       " against local symbol"),
1370
                     input_bfd,
1371
                     input_section,
1372
                     cris_elf_howto_table[r_type].name,
1373
                     rel->r_addend);
1374
                else
1375
                  (*_bfd_error_handler)
1376
                    (_("%B, section %A: relocation %s with non-zero addend %d"
1377
                       " against symbol `%s'"),
1378
                     input_bfd,
1379
                     input_section,
1380
                     cris_elf_howto_table[r_type].name,
1381
                     rel->r_addend,
1382
                     symname[0] != '\0' ? symname : _("[whose name is lost]"));
1383
 
1384
                bfd_set_error (bfd_error_bad_value);
1385
                return FALSE;
1386
              }
1387
          }
1388
          break;
1389
 
1390
        case R_CRIS_32_GOTREL:
1391
          /* This relocation must only be performed against local symbols.
1392
             It's also ok when we link a program and the symbol is either
1393
             defined in an ordinary (non-DSO) object or is undefined weak.  */
1394
          if (h != NULL
1395
              && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1396
              && !(!info->shared
1397
                   && (h->def_regular
1398
                       || (!h->def_dynamic
1399
                           && h->root.type == bfd_link_hash_undefweak))))
1400
            {
1401
              (*_bfd_error_handler)
1402
                (_("%B, section %A: relocation %s is"
1403
                   " not allowed for global symbol: `%s'"),
1404
                 input_bfd,
1405
                 input_section,
1406
                 cris_elf_howto_table[r_type].name,
1407
                 symname);
1408
              bfd_set_error (bfd_error_bad_value);
1409
              return FALSE;
1410
            }
1411
 
1412
          /* This can happen if we get a link error with the input ELF
1413
             variant mismatching the output variant.  Emit an error so
1414
             it's noticed if it happens elsewhere.  */
1415
          if (sgot == NULL)
1416
            {
1417
              (*_bfd_error_handler)
1418
                (_("%B, section %A: relocation %s with no GOT created"),
1419
                 input_bfd,
1420
                 input_section,
1421
                 cris_elf_howto_table[r_type].name);
1422
              bfd_set_error (bfd_error_bad_value);
1423
              return FALSE;
1424
            }
1425
 
1426
          /* This relocation is like a PC-relative one, except the
1427
             reference point is the location of GOT.  Note that
1428
             sgot->output_offset is not involved in this calculation.  We
1429
             always want the start of entire .got section, not the
1430
             position after the reserved header.  */
1431
          relocation -= sgot->output_section->vma;
1432
          break;
1433
 
1434
        case R_CRIS_32_PLT_PCREL:
1435
          /* Relocation is to the entry for this symbol in the
1436
             procedure linkage table.  */
1437
 
1438
          /* Resolve a PLT_PCREL reloc against a local symbol directly,
1439
             without using the procedure linkage table.  */
1440
          if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1441
            break;
1442
 
1443
          if (h->plt.offset == (bfd_vma) -1
1444
              || splt == NULL)
1445
            {
1446
              /* We didn't make a PLT entry for this symbol.  This
1447
                 happens when statically linking PIC code, or when
1448
                 using -Bsymbolic.  */
1449
              break;
1450
            }
1451
 
1452
          relocation = (splt->output_section->vma
1453
                        + splt->output_offset
1454
                        + h->plt.offset);
1455
          break;
1456
 
1457
        case R_CRIS_32_PLT_GOTREL:
1458
          /* Like R_CRIS_32_PLT_PCREL, but the reference point is the
1459
             start of the .got section.  See also comment at
1460
             R_CRIS_32_GOT.  */
1461
          relocation -= sgot->output_section->vma;
1462
 
1463
          /* Resolve a PLT_GOTREL reloc against a local symbol directly,
1464
             without using the procedure linkage table.  */
1465
          if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1466
            break;
1467
 
1468
          if (h->plt.offset == (bfd_vma) -1
1469
              || splt == NULL)
1470
            {
1471
              /* We didn't make a PLT entry for this symbol.  This
1472
                 happens when statically linking PIC code, or when
1473
                 using -Bsymbolic.  */
1474
              break;
1475
            }
1476
 
1477
          relocation = (splt->output_section->vma
1478
                        + splt->output_offset
1479
                        + h->plt.offset
1480
                        - sgot->output_section->vma);
1481
          break;
1482
 
1483
        case R_CRIS_8_PCREL:
1484
        case R_CRIS_16_PCREL:
1485
        case R_CRIS_32_PCREL:
1486
          /* If the symbol was local, we need no shlib-specific handling.  */
1487
          if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1488
              || h->dynindx == -1)
1489
            break;
1490
 
1491
          /* Fall through.  */
1492
        case R_CRIS_8:
1493
        case R_CRIS_16:
1494
        case R_CRIS_32:
1495
          if (info->shared
1496
              && r_symndx != 0
1497
              && (input_section->flags & SEC_ALLOC) != 0
1498
              && ((r_type != R_CRIS_8_PCREL
1499
                   && r_type != R_CRIS_16_PCREL
1500
                   && r_type != R_CRIS_32_PCREL)
1501
                  || (!info->symbolic
1502
                      || (h != NULL && !h->def_regular))))
1503
            {
1504
              Elf_Internal_Rela outrel;
1505
              bfd_byte *loc;
1506
              bfd_boolean skip, relocate;
1507
 
1508
              /* When generating a shared object, these relocations
1509
                 are copied into the output file to be resolved at run
1510
                 time.  */
1511
 
1512
              if (sreloc == NULL)
1513
                {
1514
                  sreloc = _bfd_elf_get_dynamic_reloc_section
1515
                    (input_bfd, input_section, /*rela?*/ TRUE);
1516
                  /* The section should have been created in cris_elf_check_relocs,
1517
                     but that function will not be called for objects which fail in
1518
                     cris_elf_merge_private_bfd_data.  */
1519
                  if (sreloc == NULL)
1520
                    {
1521
                      bfd_set_error (bfd_error_bad_value);
1522
                      return FALSE;
1523
                    }
1524
                }
1525
 
1526
              skip = FALSE;
1527
              relocate = FALSE;
1528
 
1529
              outrel.r_offset =
1530
                _bfd_elf_section_offset (output_bfd, info, input_section,
1531
                                         rel->r_offset);
1532
              if (outrel.r_offset == (bfd_vma) -1)
1533
                skip = TRUE;
1534
              else if (outrel.r_offset == (bfd_vma) -2
1535
                       /* For now, undefined weak symbols with non-default
1536
                          visibility (yielding 0), like exception info for
1537
                          discarded sections, will get a R_CRIS_NONE
1538
                          relocation rather than no relocation, because we
1539
                          notice too late that the symbol doesn't need a
1540
                          relocation.  */
1541
                       || (h != NULL
1542
                           && h->root.type == bfd_link_hash_undefweak
1543
                           && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT))
1544
                skip = TRUE, relocate = TRUE;
1545
              outrel.r_offset += (input_section->output_section->vma
1546
                                  + input_section->output_offset);
1547
 
1548
              if (skip)
1549
                memset (&outrel, 0, sizeof outrel);
1550
              /* h->dynindx may be -1 if the symbol was marked to
1551
                 become local.  */
1552
              else if (h != NULL
1553
                       && ((! info->symbolic && h->dynindx != -1)
1554
                           || !h->def_regular))
1555
                {
1556
                  BFD_ASSERT (h->dynindx != -1);
1557
                  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1558
                  outrel.r_addend = relocation + rel->r_addend;
1559
                }
1560
              else
1561
                {
1562
                  outrel.r_addend = relocation + rel->r_addend;
1563
 
1564
                  if (r_type == R_CRIS_32)
1565
                    {
1566
                      relocate = TRUE;
1567
                      outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1568
                    }
1569
                  else
1570
                    {
1571
                      long indx;
1572
 
1573
                      if (bfd_is_abs_section (sec))
1574
                        indx = 0;
1575
                      else if (sec == NULL || sec->owner == NULL)
1576
                        {
1577
                          bfd_set_error (bfd_error_bad_value);
1578
                          return FALSE;
1579
                        }
1580
                      else
1581
                        {
1582
                          asection *osec;
1583
 
1584
                          /* We are turning this relocation into one
1585
                             against a section symbol.  It would be
1586
                             proper to subtract the symbol's value,
1587
                             osec->vma, from the emitted reloc addend,
1588
                             but ld.so expects buggy relocs.  */
1589
                          osec = sec->output_section;
1590
                          indx = elf_section_data (osec)->dynindx;
1591
                          if (indx == 0)
1592
                            {
1593
                              osec = htab->root.text_index_section;
1594
                              indx = elf_section_data (osec)->dynindx;
1595
                            }
1596
                          BFD_ASSERT (indx != 0);
1597
                        }
1598
 
1599
                      outrel.r_info = ELF32_R_INFO (indx, r_type);
1600
                    }
1601
                }
1602
 
1603
              loc = sreloc->contents;
1604
              loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1605
              bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1606
 
1607
              /* This reloc will be computed at runtime, so there's no
1608
                 need to do anything now, except for R_CRIS_32 relocations
1609
                 that have been turned into R_CRIS_RELATIVE.  */
1610
              if (!relocate)
1611
                continue;
1612
            }
1613
 
1614
          break;
1615
 
1616
        case R_CRIS_16_DTPREL:
1617
        case R_CRIS_32_DTPREL:
1618
          /* This relocation must only be performed against local
1619
             symbols, or to sections that are not loadable.  It's also
1620
             ok when we link a program and the symbol is defined in an
1621
             ordinary (non-DSO) object (if it's undefined there, we've
1622
             already seen an error).  */
1623
          if (h != NULL
1624
              && (input_section->flags & SEC_ALLOC) != 0
1625
              && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1626
              && (info->shared
1627
                  || (!h->def_regular
1628
                      && h->root.type != bfd_link_hash_undefined)))
1629
            {
1630
              (*_bfd_error_handler)
1631
                ((h->root.type == bfd_link_hash_undefined)
1632
                 /* We shouldn't get here for GCC-emitted code.  */
1633
                 ? _("%B, section %A: relocation %s has an undefined"
1634
                     " reference to `%s', perhaps a declaration mixup?")
1635
                 : ("%B, section %A: relocation %s is"
1636
                     " not allowed for `%s', a global symbol with default"
1637
                     " visibility, perhaps a declaration mixup?"),
1638
                 input_bfd,
1639
                 input_section,
1640
                 cris_elf_howto_table[r_type].name,
1641
                 symname != NULL && symname[0] != '\0'
1642
                 ? symname : _("[whose name is lost]"));
1643
              bfd_set_error (bfd_error_bad_value);
1644
              return FALSE;
1645
            }
1646
 
1647
          BFD_ASSERT ((input_section->flags & SEC_ALLOC) == 0
1648
                      || htab->dtpmod_refcount != 0);
1649
 
1650
          /* Fill in a R_CRIS_DTPMOD reloc at offset 3 if we haven't
1651
             already done so.  Note that we do this in .got.plt, not
1652
             in .got, as .got.plt contains the first part, still the
1653
             reloc is against .got, because the linker script directs
1654
             (is required to direct) them both into .got.  */
1655
          if (htab->dtpmod_refcount > 0
1656
              && (input_section->flags & SEC_ALLOC) != 0)
1657
            {
1658
              asection *sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1659
              BFD_ASSERT (sgotplt != NULL);
1660
 
1661
              if (info->shared)
1662
                {
1663
                  Elf_Internal_Rela outrel;
1664
                  bfd_byte *loc;
1665
 
1666
                  if (srelgot == NULL)
1667
                    srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1668
                  BFD_ASSERT (srelgot != NULL);
1669
                  loc = srelgot->contents;
1670
                  loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1671
 
1672
                  bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 12);
1673
                  bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 16);
1674
                  outrel.r_offset = (sgotplt->output_section->vma
1675
                                     + sgotplt->output_offset
1676
                                     + 12);
1677
                  outrel.r_info = ELF32_R_INFO (0, R_CRIS_DTPMOD);
1678
                  outrel.r_addend = 0;
1679
                  bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1680
                }
1681
              else
1682
                {
1683
                  /* For an executable, the GOT entry contents is known.  */
1684
                  bfd_put_32 (output_bfd, (bfd_vma) 1, sgotplt->contents + 12);
1685
                  bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 16);
1686
                }
1687
 
1688
              /* Reverse the sign to mark that we've emitted the
1689
                 required GOT entry.  */
1690
              htab->dtpmod_refcount = - htab->dtpmod_refcount;
1691
            }
1692
 
1693
          /* The relocation is the offset from the start of the module
1694
             TLS block to the (local) symbol.  */
1695
          relocation -= elf_hash_table (info)->tls_sec == NULL
1696
            ? 0 : elf_hash_table (info)->tls_sec->vma;
1697
          break;
1698
 
1699
        case R_CRIS_32_GD:
1700
          if (info->shared)
1701
            {
1702
              bfd_set_error (bfd_error_invalid_operation);
1703
 
1704
              /* We've already informed in cris_elf_check_relocs that
1705
                 this is an error.  */
1706
              return FALSE;
1707
            }
1708
          /* Fall through.  */
1709
 
1710
        case R_CRIS_16_GOT_GD:
1711
        case R_CRIS_32_GOT_GD:
1712
          if (rel->r_addend != 0)
1713
            {
1714
              /* We can't do anything for a relocation which is against a
1715
                 symbol *plus offset*.  The GOT holds relocations for
1716
                 symbols.  Make this an error; the compiler isn't allowed
1717
                 to pass us these kinds of things.  */
1718
              (*_bfd_error_handler)
1719
                (_("%B, section %A: relocation %s with non-zero addend %d"
1720
                   " against symbol `%s'"),
1721
                 input_bfd,
1722
                 input_section,
1723
                 cris_elf_howto_table[r_type].name,
1724
                 rel->r_addend,
1725
                 symname[0] != '\0' ? symname : _("[whose name is lost]"));
1726
 
1727
              bfd_set_error (bfd_error_bad_value);
1728
              return FALSE;
1729
            }
1730
 
1731
          if (!info->shared
1732
              && (h == NULL || h->def_regular || ELF_COMMON_DEF_P (h)))
1733
            {
1734
              /* Known contents of the GOT.  */
1735
              bfd_vma off;
1736
 
1737
              /* The symbol is defined in the program, so just write
1738
                 (1, known_tpoffset) into the GOT.  */
1739
              relocation -= elf_hash_table (info)->tls_sec->vma;
1740
 
1741
              if (h != NULL)
1742
                {
1743
                  off = elf_cris_hash_entry (h)->tprel_refcount > 0
1744
                    ? h->got.offset + 4 : h->got.offset;
1745
                }
1746
              else
1747
                {
1748
                  off = local_got_offsets[r_symndx];
1749
                  if (local_got_offsets[LGOT_TPREL_NDX (r_symndx)])
1750
                    off += 4;
1751
                }
1752
 
1753
              /* We use bit 1 of the offset as a flag for GOT entry with
1754
                 the R_CRIS_DTP reloc, setting it when we've emitted the
1755
                 GOT entry and reloc.  Bit 0 is used for R_CRIS_32_TPREL
1756
                 relocs.  */
1757
              if ((off & 2) == 0)
1758
                {
1759
                  off &= ~3;
1760
 
1761
                  if (h != NULL)
1762
                    h->got.offset |= 2;
1763
                  else
1764
                    local_got_offsets[r_symndx] |= 2;
1765
 
1766
                  bfd_put_32 (output_bfd, 1, sgot->contents + off);
1767
                  bfd_put_32 (output_bfd, relocation, sgot->contents + off + 4);
1768
                }
1769
              else
1770
                off &= ~3;
1771
 
1772
              relocation = sgot->output_offset + off
1773
                + (r_type == R_CRIS_32_GD ? sgot->output_section->vma : 0);
1774
            }
1775
          else
1776
            {
1777
              /* Not all parts of the GOT entry are known; emit a real
1778
                 relocation.  */
1779
              bfd_vma off;
1780
 
1781
              if (h != NULL)
1782
                off = elf_cris_hash_entry (h)->tprel_refcount > 0
1783
                  ? h->got.offset + 4 : h->got.offset;
1784
              else
1785
                {
1786
                  off = local_got_offsets[r_symndx];
1787
                  if (local_got_offsets[LGOT_TPREL_NDX (r_symndx)])
1788
                    off += 4;
1789
                }
1790
 
1791
              /* See above re bit 1 and bit 0 usage.  */
1792
              if ((off & 2) == 0)
1793
                {
1794
                  Elf_Internal_Rela outrel;
1795
                  bfd_byte *loc;
1796
 
1797
                  off &= ~3;
1798
 
1799
                  if (h != NULL)
1800
                    h->got.offset |= 2;
1801
                  else
1802
                    local_got_offsets[r_symndx] |= 2;
1803
 
1804
                  /* Clear the target contents of the GOT (just as a
1805
                     gesture; it's already cleared on allocation): this
1806
                     relocation is not like the other dynrelocs.  */
1807
                  bfd_put_32 (output_bfd, 0, sgot->contents + off);
1808
                  bfd_put_32 (output_bfd, 0, sgot->contents + off + 4);
1809
 
1810
                  if (srelgot == NULL)
1811
                    srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1812
                  BFD_ASSERT (srelgot != NULL);
1813
 
1814
                  if (h != NULL && h->dynindx != -1)
1815
                    {
1816
                      outrel.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_DTP);
1817
                      relocation = 0;
1818
                    }
1819
                  else
1820
                    {
1821
                      outrel.r_info = ELF32_R_INFO (0, R_CRIS_DTP);
1822
 
1823
                      /* NULL if we had an error.  */
1824
                      relocation -= elf_hash_table (info)->tls_sec == NULL
1825
                        ? 0 : elf_hash_table (info)->tls_sec->vma;
1826
                    }
1827
 
1828
                  outrel.r_offset = (sgot->output_section->vma
1829
                                     + sgot->output_offset
1830
                                     + off);
1831
                  outrel.r_addend = relocation;
1832
                  loc = srelgot->contents;
1833
                  loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1834
 
1835
                  /* NULL if we had an error.  */
1836
                  if (srelgot->contents != NULL)
1837
                    bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1838
                }
1839
              else
1840
                off &= ~3;
1841
 
1842
              relocation = sgot->output_offset + off
1843
                + (r_type == R_CRIS_32_GD ? sgot->output_section->vma : 0);
1844
            }
1845
 
1846
          /* The GOT-relative offset to the GOT entry is the
1847
             relocation, or for R_CRIS_32_GD, the actual address of
1848
             the GOT entry.  */
1849
          break;
1850
 
1851
        case R_CRIS_32_IE:
1852
          if (info->shared)
1853
            {
1854
              bfd_set_error (bfd_error_invalid_operation);
1855
 
1856
              /* We've already informed in cris_elf_check_relocs that
1857
                 this is an error.  */
1858
              return FALSE;
1859
            }
1860
          /* Fall through.  */
1861
 
1862
        case R_CRIS_32_GOT_TPREL:
1863
        case R_CRIS_16_GOT_TPREL:
1864
          if (rel->r_addend != 0)
1865
            {
1866
              /* We can't do anything for a relocation which is
1867
                 against a symbol *plus offset*.  GOT holds
1868
                 relocations for symbols.  Make this an error; the
1869
                 compiler isn't allowed to pass us these kinds of
1870
                 things.  */
1871
              (*_bfd_error_handler)
1872
                (_("%B, section %A: relocation %s with non-zero addend %d"
1873
                   " against symbol `%s'"),
1874
                 input_bfd,
1875
                 input_section,
1876
                 cris_elf_howto_table[r_type].name,
1877
                 rel->r_addend,
1878
                 symname[0] != '\0' ? symname : _("[whose name is lost]"));
1879
              bfd_set_error (bfd_error_bad_value);
1880
              return FALSE;
1881
            }
1882
 
1883
          if (!info->shared && (h == NULL || h->def_regular))
1884
            {
1885
              /* Known contents of the GOT.  */
1886
              bfd_vma off;
1887
 
1888
              /* The symbol is defined in the program, so just write
1889
                 the -prog_tls_size+known_tpoffset into the GOT.  */
1890
              relocation -= elf_hash_table (info)->tls_sec->vma;
1891
              relocation -= elf_hash_table (info)->tls_size;
1892
 
1893
              if (h != NULL)
1894
                off = h->got.offset;
1895
              else
1896
                off = local_got_offsets[r_symndx];
1897
 
1898
              /* Bit 0 is used to mark whether we've emitted the required
1899
                 entry (and if needed R_CRIS_32_TPREL reloc).  Bit 1
1900
                 is used similarly for R_CRIS_DTP, see above.  */
1901
              if ((off & 1) == 0)
1902
                {
1903
                  off &= ~3;
1904
 
1905
                  if (h != NULL)
1906
                    h->got.offset |= 1;
1907
                  else
1908
                    local_got_offsets[r_symndx] |= 1;
1909
 
1910
                  bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1911
                }
1912
              else
1913
                off &= ~3;
1914
 
1915
              relocation = sgot->output_offset + off
1916
                + (r_type == R_CRIS_32_IE ? sgot->output_section->vma : 0);
1917
            }
1918
          else
1919
            {
1920
              /* Emit a real relocation.  */
1921
              bfd_vma off;
1922
 
1923
              if (h != NULL)
1924
                off = h->got.offset;
1925
              else
1926
                off = local_got_offsets[r_symndx];
1927
 
1928
              /* See above re usage of bit 0 and 1.  */
1929
              if ((off & 1) == 0)
1930
                {
1931
                  Elf_Internal_Rela outrel;
1932
                  bfd_byte *loc;
1933
 
1934
                  off &= ~3;
1935
 
1936
                  if (h != NULL)
1937
                    h->got.offset |= 1;
1938
                  else
1939
                    local_got_offsets[r_symndx] |= 1;
1940
 
1941
                  if (srelgot == NULL)
1942
                    srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1943
                  BFD_ASSERT (srelgot != NULL);
1944
 
1945
                  if (h != NULL && h->dynindx != -1)
1946
                    {
1947
                      outrel.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_32_TPREL);
1948
                      relocation = 0;
1949
                    }
1950
                  else
1951
                    {
1952
                      outrel.r_info = ELF32_R_INFO (0, R_CRIS_32_TPREL);
1953
 
1954
                      /* NULL if we had an error.  */
1955
                      relocation -= elf_hash_table (info)->tls_sec == NULL
1956
                        ? 0 : elf_hash_table (info)->tls_sec->vma;
1957
                    }
1958
 
1959
                  /* Just "define" the initial contents in some
1960
                     semi-logical way.  */
1961
                  bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1962
 
1963
                  outrel.r_offset = (sgot->output_section->vma
1964
                                     + sgot->output_offset
1965
                                     + off);
1966
                  outrel.r_addend = relocation;
1967
                  loc = srelgot->contents;
1968
                  loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1969
                  /* NULL if we had an error.  */
1970
                  if (srelgot->contents != NULL)
1971
                    bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1972
                }
1973
              else
1974
                off &= ~3;
1975
 
1976
              relocation = sgot->output_offset + off
1977
                + (r_type == R_CRIS_32_IE ? sgot->output_section->vma : 0);
1978
            }
1979
 
1980
          /* The GOT-relative offset to the GOT entry is the relocation,
1981
             or for R_CRIS_32_GD, the actual address of the GOT entry.  */
1982
          break;
1983
 
1984
        case R_CRIS_16_TPREL:
1985
        case R_CRIS_32_TPREL:
1986
          /* This relocation must only be performed against symbols
1987
             defined in an ordinary (non-DSO) object.  */
1988
          if (info->shared)
1989
            {
1990
              bfd_set_error (bfd_error_invalid_operation);
1991
 
1992
              /* We've already informed in cris_elf_check_relocs that
1993
                 this is an error.  */
1994
              return FALSE;
1995
            }
1996
 
1997
          if (h != NULL
1998
              && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1999
              && !(h->def_regular || ELF_COMMON_DEF_P (h))
2000
              /* If it's undefined, then an error message has already
2001
                 been emitted.  */
2002
              && h->root.type != bfd_link_hash_undefined)
2003
            {
2004
              (*_bfd_error_handler)
2005
                (_("%B, section %A: relocation %s is"
2006
                   " not allowed for symbol: `%s'"
2007
                   " which is defined outside the program,"
2008
                   " perhaps a declaration mixup?"),
2009
                 input_bfd,
2010
                 input_section,
2011
                 cris_elf_howto_table[r_type].name,
2012
                 symname);
2013
              bfd_set_error (bfd_error_bad_value);
2014
              return FALSE;
2015
            }
2016
 
2017
          /* NULL if we had an error.  */
2018
          relocation -= elf_hash_table (info)->tls_sec == NULL
2019
            ? 0
2020
            : (elf_hash_table (info)->tls_sec->vma
2021
               + elf_hash_table (info)->tls_size);
2022
 
2023
          /* The TLS-relative offset is the relocation.  */
2024
          break;
2025
 
2026
        default:
2027
          BFD_FAIL ();
2028
          return FALSE;
2029
        }
2030
 
2031
      r = cris_final_link_relocate (howto, input_bfd, input_section,
2032
                                     contents, rel, relocation);
2033
 
2034
      if (r != bfd_reloc_ok)
2035
        {
2036
          const char * msg = (const char *) NULL;
2037
 
2038
          switch (r)
2039
            {
2040
            case bfd_reloc_overflow:
2041
              r = info->callbacks->reloc_overflow
2042
                (info, (h ? &h->root : NULL), symname, howto->name,
2043
                 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2044
              if (additional_relocation_error_msg_count > 0)
2045
                {
2046
                  additional_relocation_error_msg_count--;
2047
                  switch (r_type)
2048
                    {
2049
                    case R_CRIS_16_GOTPLT:
2050
                    case R_CRIS_16_GOT:
2051
 
2052
                      /* Not just TLS is involved here, so we make
2053
                         generation and message depend on -fPIC/-fpic
2054
                         only.  */
2055
                    case R_CRIS_16_GOT_TPREL:
2056
                    case R_CRIS_16_GOT_GD:
2057
                      (*_bfd_error_handler)
2058
                        (_("(too many global variables for -fpic:"
2059
                           " recompile with -fPIC)"));
2060
                      break;
2061
 
2062
                    case R_CRIS_16_TPREL:
2063
                    case R_CRIS_16_DTPREL:
2064
                      (*_bfd_error_handler)
2065
                        (_("(thread-local data too big for -fpic or"
2066
                           " -msmall-tls: recompile with -fPIC or"
2067
                           " -mno-small-tls)"));
2068
                      break;
2069
 
2070
                      /* No known cause for overflow for other relocs.  */
2071
                    default:
2072
                      break;
2073
                    }
2074
                }
2075
              break;
2076
 
2077
            case bfd_reloc_undefined:
2078
              r = info->callbacks->undefined_symbol
2079
                (info, symname, input_bfd, input_section, rel->r_offset,
2080
                 TRUE);
2081
              break;
2082
 
2083
            case bfd_reloc_outofrange:
2084
              msg = _("internal error: out of range error");
2085
              break;
2086
 
2087
            case bfd_reloc_notsupported:
2088
              msg = _("internal error: unsupported relocation error");
2089
              break;
2090
 
2091
            case bfd_reloc_dangerous:
2092
              msg = _("internal error: dangerous relocation");
2093
              break;
2094
 
2095
            default:
2096
              msg = _("internal error: unknown error");
2097
              break;
2098
            }
2099
 
2100
          if (msg)
2101
            r = info->callbacks->warning
2102
              (info, msg, symname, input_bfd, input_section, rel->r_offset);
2103
 
2104
          if (! r)
2105
            return FALSE;
2106
        }
2107
    }
2108
 
2109
  return TRUE;
2110
}
2111
 
2112
/* Finish up dynamic symbol handling.  We set the contents of various
2113
   dynamic sections here.  */
2114
 
2115
static bfd_boolean
2116
elf_cris_finish_dynamic_symbol (bfd *output_bfd,
2117
                                struct bfd_link_info *info,
2118
                                struct elf_link_hash_entry *h,
2119
                                Elf_Internal_Sym *sym)
2120
{
2121
  struct elf_cris_link_hash_table * htab;
2122
  bfd *dynobj;
2123
 
2124
  /* Where in the plt entry to put values.  */
2125
  int plt_off1 = 2, plt_off2 = 10, plt_off3 = 16;
2126
 
2127
  /* What offset to add to the distance to the first PLT entry for the
2128
     value at plt_off3.   */
2129
  int plt_off3_value_bias = 4;
2130
 
2131
  /* Where in the PLT entry the call-dynlink-stub is (happens to be same
2132
     for PIC and non-PIC for v32 and pre-v32).  */
2133
  int plt_stub_offset = 8;
2134
  int plt_entry_size = PLT_ENTRY_SIZE;
2135
  const bfd_byte *plt_entry = elf_cris_plt_entry;
2136
  const bfd_byte *plt_pic_entry = elf_cris_pic_plt_entry;
2137
 
2138
  htab = elf_cris_hash_table (info);
2139
  if (htab == NULL)
2140
    return FALSE;
2141
 
2142
  /* Adjust the various PLT entry offsets.  */
2143
  if (bfd_get_mach (output_bfd) == bfd_mach_cris_v32)
2144
    {
2145
      plt_off2 = 14;
2146
      plt_off3 = 20;
2147
      plt_off3_value_bias = -2;
2148
      plt_stub_offset = 12;
2149
      plt_entry_size = PLT_ENTRY_SIZE_V32;
2150
      plt_entry = elf_cris_plt_entry_v32;
2151
      plt_pic_entry = elf_cris_pic_plt_entry_v32;
2152
    }
2153
 
2154
  dynobj = elf_hash_table (info)->dynobj;
2155
 
2156
  if (h->plt.offset != (bfd_vma) -1)
2157
    {
2158
      asection *splt;
2159
      asection *sgotplt;
2160
      asection *sgot;
2161
      asection *srela;
2162
      bfd_vma got_base;
2163
 
2164
      bfd_vma gotplt_offset
2165
        = elf_cris_hash_entry (h)->gotplt_offset;
2166
      Elf_Internal_Rela rela;
2167
      bfd_byte *loc;
2168
      bfd_boolean has_gotplt = gotplt_offset != 0;
2169
 
2170
      /* Get the index in the .rela.plt relocations for the .got.plt
2171
         entry that corresponds to this symbol.
2172
         We have to count backwards here, and the result is only valid
2173
         as an index into .rela.plt.  We also have to undo the effect
2174
         of the R_CRIS_DTPMOD entry at .got index 3 (offset 12 into
2175
         .got.plt) for which gotplt_offset is adjusted, because while
2176
         that entry goes into .got.plt, its relocation goes into
2177
         .rela.got, not .rela.plt.  (It's not PLT-specific; not to be
2178
         processed as part of the runtime lazy .rela.plt relocation).
2179
         FIXME: There be literal constants here...  */
2180
      bfd_vma rela_plt_index
2181
        = (htab->dtpmod_refcount != 0
2182
           ? gotplt_offset/4 - 2 - 3 : gotplt_offset/4 - 3);
2183
 
2184
      /* Get the offset into the .got table of the entry that corresponds
2185
         to this function.  Note that we embed knowledge that "incoming"
2186
         .got goes after .got.plt in the output without padding (pointer
2187
         aligned).  However, that knowledge is present in several other
2188
         places too.  */
2189
      bfd_vma got_offset
2190
        = (has_gotplt
2191
           ? gotplt_offset
2192
           : h->got.offset + htab->next_gotplt_entry);
2193
 
2194
      /* This symbol has an entry in the procedure linkage table.  Set it
2195
         up.  */
2196
 
2197
      BFD_ASSERT (h->dynindx != -1);
2198
 
2199
      splt = bfd_get_section_by_name (dynobj, ".plt");
2200
      sgot = bfd_get_section_by_name (dynobj, ".got");
2201
      sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
2202
      srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2203
      BFD_ASSERT (splt != NULL && sgotplt != NULL
2204
                  && (! has_gotplt || srela != NULL));
2205
 
2206
      got_base = sgotplt->output_section->vma + sgotplt->output_offset;
2207
 
2208
      /* Fill in the entry in the procedure linkage table.  */
2209
      if (! info->shared)
2210
        {
2211
          memcpy (splt->contents + h->plt.offset, plt_entry,
2212
                  plt_entry_size);
2213
 
2214
          /* We need to enter the absolute address of the GOT entry here.  */
2215
          bfd_put_32 (output_bfd, got_base + got_offset,
2216
                      splt->contents + h->plt.offset + plt_off1);
2217
        }
2218
      else
2219
        {
2220
          memcpy (splt->contents + h->plt.offset, plt_pic_entry,
2221
                  plt_entry_size);
2222
          bfd_put_32 (output_bfd, got_offset,
2223
                      splt->contents + h->plt.offset + plt_off1);
2224
        }
2225
 
2226
      /* Fill in the plt entry and make a relocation, if this is a "real"
2227
         PLT entry.  */
2228
      if (has_gotplt)
2229
        {
2230
          /* Fill in the offset to the reloc table.  */
2231
          bfd_put_32 (output_bfd,
2232
                      rela_plt_index * sizeof (Elf32_External_Rela),
2233
                      splt->contents + h->plt.offset + plt_off2);
2234
 
2235
          /* Fill in the offset to the first PLT entry, where to "jump".  */
2236
          bfd_put_32 (output_bfd,
2237
                      - (h->plt.offset + plt_off3 + plt_off3_value_bias),
2238
                      splt->contents + h->plt.offset + plt_off3);
2239
 
2240
          /* Fill in the entry in the global offset table with the address of
2241
             the relocating stub.  */
2242
          bfd_put_32 (output_bfd,
2243
                      (splt->output_section->vma
2244
                       + splt->output_offset
2245
                       + h->plt.offset
2246
                       + plt_stub_offset),
2247
                      sgotplt->contents + got_offset);
2248
 
2249
          /* Fill in the entry in the .rela.plt section.  */
2250
          rela.r_offset = (sgotplt->output_section->vma
2251
                           + sgotplt->output_offset
2252
                           + got_offset);
2253
          rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_JUMP_SLOT);
2254
          rela.r_addend = 0;
2255
          loc = srela->contents + rela_plt_index * sizeof (Elf32_External_Rela);
2256
          bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2257
        }
2258
 
2259
      if (!h->def_regular)
2260
        {
2261
          /* Mark the symbol as undefined, rather than as defined in
2262
             the .plt section.  Leave the value alone.  */
2263
          sym->st_shndx = SHN_UNDEF;
2264
 
2265
          /* FIXME: From elf32-sparc.c 2001-02-19 (1.18).  I still don't
2266
             know whether resetting the value is significant; if it really
2267
             is, rather than a quirk or bug in the sparc port, then I
2268
             believe we'd see this elsewhere.  */
2269
          /* If the symbol is weak, we do need to clear the value.
2270
             Otherwise, the PLT entry would provide a definition for
2271
             the symbol even if the symbol wasn't defined anywhere,
2272
             and so the symbol would never be NULL.  */
2273
          if (!h->ref_regular_nonweak)
2274
            sym->st_value = 0;
2275
        }
2276
    }
2277
 
2278
  /* For an ordinary program, we emit .got relocs only for symbols that
2279
     are in the dynamic-symbols table and are either defined by the
2280
     program or are undefined weak symbols, or are function symbols
2281
     where we do not output a PLT: the PLT reloc was output above and all
2282
     references to the function symbol are redirected to the PLT.  */
2283
  if (h->got.offset != (bfd_vma) -1
2284
      && (elf_cris_hash_entry (h)->reg_got_refcount > 0)
2285
      && (info->shared
2286
          || (h->dynindx != -1
2287
              && h->plt.offset == (bfd_vma) -1
2288
              && !h->def_regular
2289
              && h->root.type != bfd_link_hash_undefweak)))
2290
    {
2291
      asection *sgot;
2292
      asection *srela;
2293
      Elf_Internal_Rela rela;
2294
      bfd_byte *loc;
2295
      bfd_byte *where;
2296
 
2297
      /* This symbol has an entry in the global offset table.  Set it up.  */
2298
 
2299
      sgot = bfd_get_section_by_name (dynobj, ".got");
2300
      srela = bfd_get_section_by_name (dynobj, ".rela.got");
2301
      BFD_ASSERT (sgot != NULL && srela != NULL);
2302
 
2303
      rela.r_offset = (sgot->output_section->vma
2304
                       + sgot->output_offset
2305
                       + (h->got.offset &~ (bfd_vma) 1));
2306
 
2307
      /* If this is a static link, or it is a -Bsymbolic link and the
2308
         symbol is defined locally or was forced to be local because
2309
         of a version file, we just want to emit a RELATIVE reloc.
2310
         The entry in the global offset table will already have been
2311
         initialized in the relocate_section function.  */
2312
      where = sgot->contents + (h->got.offset &~ (bfd_vma) 1);
2313
      if (! elf_hash_table (info)->dynamic_sections_created
2314
          || (info->shared
2315
              && (info->symbolic || h->dynindx == -1)
2316
              && h->def_regular))
2317
        {
2318
          rela.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
2319
          rela.r_addend = bfd_get_signed_32 (output_bfd, where);
2320
        }
2321
      else
2322
        {
2323
          bfd_put_32 (output_bfd, (bfd_vma) 0, where);
2324
          rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_GLOB_DAT);
2325
          rela.r_addend = 0;
2326
        }
2327
 
2328
      loc = srela->contents;
2329
      loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
2330
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2331
    }
2332
 
2333
  if (h->needs_copy)
2334
    {
2335
      asection *s;
2336
      Elf_Internal_Rela rela;
2337
      bfd_byte *loc;
2338
 
2339
      /* This symbol needs a copy reloc.  Set it up.  */
2340
 
2341
      BFD_ASSERT (h->dynindx != -1
2342
                  && (h->root.type == bfd_link_hash_defined
2343
                      || h->root.type == bfd_link_hash_defweak));
2344
 
2345
      s = bfd_get_section_by_name (h->root.u.def.section->owner,
2346
                                   ".rela.bss");
2347
      BFD_ASSERT (s != NULL);
2348
 
2349
      rela.r_offset = (h->root.u.def.value
2350
                       + h->root.u.def.section->output_section->vma
2351
                       + h->root.u.def.section->output_offset);
2352
      rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_COPY);
2353
      rela.r_addend = 0;
2354
      loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
2355
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2356
    }
2357
 
2358
  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2359
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2360
      || h == elf_hash_table (info)->hgot)
2361
    sym->st_shndx = SHN_ABS;
2362
 
2363
  return TRUE;
2364
}
2365
 
2366
/* Finish up the dynamic sections.  Do *not* emit relocs here, as their
2367
   offsets were changed, as part of -z combreloc handling, from those we
2368
   computed.  */
2369
 
2370
static bfd_boolean
2371
elf_cris_finish_dynamic_sections (output_bfd, info)
2372
     bfd *output_bfd;
2373
     struct bfd_link_info *info;
2374
{
2375
  bfd *dynobj;
2376
  asection *sgot;
2377
  asection *sdyn;
2378
 
2379
  dynobj = elf_hash_table (info)->dynobj;
2380
 
2381
  sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2382
  BFD_ASSERT (sgot != NULL);
2383
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2384
 
2385
  if (elf_hash_table (info)->dynamic_sections_created)
2386
    {
2387
      asection *splt;
2388
      Elf32_External_Dyn *dyncon, *dynconend;
2389
 
2390
      splt = bfd_get_section_by_name (dynobj, ".plt");
2391
      BFD_ASSERT (splt != NULL && sdyn != NULL);
2392
 
2393
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
2394
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2395
      for (; dyncon < dynconend; dyncon++)
2396
        {
2397
          Elf_Internal_Dyn dyn;
2398
          asection *s;
2399
 
2400
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2401
 
2402
          switch (dyn.d_tag)
2403
            {
2404
            default:
2405
              break;
2406
 
2407
            case DT_PLTGOT:
2408
              s = bfd_get_section_by_name (output_bfd, ".got");
2409
              BFD_ASSERT (s != NULL);
2410
              dyn.d_un.d_ptr = s->vma;
2411
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2412
              break;
2413
 
2414
            case DT_JMPREL:
2415
              /* Yes, we *can* have a .plt and no .plt.rela, for instance
2416
                 if all symbols are found in the .got (not .got.plt).  */
2417
              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2418
              dyn.d_un.d_ptr = s != NULL ? s->vma : 0;
2419
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2420
              break;
2421
 
2422
            case DT_PLTRELSZ:
2423
              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2424
              if (s == NULL)
2425
                dyn.d_un.d_val = 0;
2426
              else
2427
                dyn.d_un.d_val = s->size;
2428
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2429
              break;
2430
 
2431
            case DT_RELASZ:
2432
              /* The procedure linkage table relocs (DT_JMPREL) should
2433
                 not be included in the overall relocs (DT_RELA).
2434
                 Therefore, we override the DT_RELASZ entry here to
2435
                 make it not include the JMPREL relocs.  Since the
2436
                 linker script arranges for .rela.plt to follow all
2437
                 other relocation sections, we don't have to worry
2438
                 about changing the DT_RELA entry.  */
2439
              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2440
              if (s != NULL)
2441
                dyn.d_un.d_val -= s->size;
2442
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2443
              break;
2444
            }
2445
        }
2446
 
2447
      /* Fill in the first entry in the procedure linkage table.  */
2448
      if (splt->size > 0)
2449
        {
2450
          if (bfd_get_mach (output_bfd) == bfd_mach_cris_v32)
2451
            {
2452
              if (info->shared)
2453
                memcpy (splt->contents, elf_cris_pic_plt0_entry_v32,
2454
                        PLT_ENTRY_SIZE_V32);
2455
              else
2456
                {
2457
                  memcpy (splt->contents, elf_cris_plt0_entry_v32,
2458
                          PLT_ENTRY_SIZE_V32);
2459
                  bfd_put_32 (output_bfd,
2460
                              sgot->output_section->vma
2461
                              + sgot->output_offset + 4,
2462
                              splt->contents + 4);
2463
 
2464
                  elf_section_data (splt->output_section)->this_hdr.sh_entsize
2465
                    = PLT_ENTRY_SIZE_V32;
2466
                }
2467
            }
2468
          else
2469
            {
2470
              if (info->shared)
2471
                memcpy (splt->contents, elf_cris_pic_plt0_entry,
2472
                        PLT_ENTRY_SIZE);
2473
              else
2474
                {
2475
                  memcpy (splt->contents, elf_cris_plt0_entry,
2476
                          PLT_ENTRY_SIZE);
2477
                  bfd_put_32 (output_bfd,
2478
                              sgot->output_section->vma
2479
                              + sgot->output_offset + 4,
2480
                              splt->contents + 6);
2481
                  bfd_put_32 (output_bfd,
2482
                              sgot->output_section->vma
2483
                              + sgot->output_offset + 8,
2484
                              splt->contents + 14);
2485
 
2486
                  elf_section_data (splt->output_section)->this_hdr.sh_entsize
2487
                    = PLT_ENTRY_SIZE;
2488
                }
2489
            }
2490
        }
2491
    }
2492
 
2493
  /* Fill in the first three entries in the global offset table.  */
2494
  if (sgot->size > 0)
2495
    {
2496
      if (sdyn == NULL)
2497
        bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2498
      else
2499
        bfd_put_32 (output_bfd,
2500
                    sdyn->output_section->vma + sdyn->output_offset,
2501
                    sgot->contents);
2502
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2503
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2504
    }
2505
 
2506
  elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2507
 
2508
  return TRUE;
2509
}
2510
 
2511
/* Return the section that should be marked against GC for a given
2512
   relocation.  */
2513
 
2514
static asection *
2515
cris_elf_gc_mark_hook (asection *sec,
2516
                       struct bfd_link_info *info,
2517
                       Elf_Internal_Rela *rel,
2518
                       struct elf_link_hash_entry *h,
2519
                       Elf_Internal_Sym *sym)
2520
{
2521
  enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rel->r_info);
2522
  if (h != NULL)
2523
    switch (r_type)
2524
      {
2525
      case R_CRIS_GNU_VTINHERIT:
2526
      case R_CRIS_GNU_VTENTRY:
2527
        return NULL;
2528
 
2529
      default:
2530
        break;
2531
      }
2532
 
2533
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2534
}
2535
 
2536
/* Update the got entry reference counts for the section being removed.  */
2537
 
2538
static bfd_boolean
2539
cris_elf_gc_sweep_hook (bfd *abfd,
2540
                        struct bfd_link_info *info,
2541
                        asection *sec,
2542
                        const Elf_Internal_Rela *relocs)
2543
{
2544
  struct elf_cris_link_hash_table * htab;
2545
  Elf_Internal_Shdr *symtab_hdr;
2546
  struct elf_link_hash_entry **sym_hashes;
2547
  bfd_signed_vma *local_got_refcounts;
2548
  const Elf_Internal_Rela *rel, *relend;
2549
  bfd *dynobj;
2550
  asection *sgot;
2551
  asection *srelgot;
2552
 
2553
  if (info->relocatable)
2554
    return TRUE;
2555
 
2556
  dynobj = elf_hash_table (info)->dynobj;
2557
  if (dynobj == NULL)
2558
    return TRUE;
2559
 
2560
  htab = elf_cris_hash_table (info);
2561
  if (htab == NULL)
2562
    return FALSE;
2563
 
2564
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2565
  sym_hashes = elf_sym_hashes (abfd);
2566
  local_got_refcounts = elf_local_got_refcounts (abfd);
2567
 
2568
  sgot = bfd_get_section_by_name (dynobj, ".got");
2569
  srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2570
 
2571
  relend = relocs + sec->reloc_count;
2572
  for (rel = relocs; rel < relend; rel++)
2573
    {
2574
      unsigned long r_symndx;
2575
      struct elf_link_hash_entry *h = NULL;
2576
      bfd_signed_vma got_element_size = 4;
2577
      bfd_signed_vma *specific_refcount = NULL;
2578
      enum elf_cris_reloc_type r_type;
2579
 
2580
      r_symndx = ELF32_R_SYM (rel->r_info);
2581
      if (r_symndx >= symtab_hdr->sh_info)
2582
        {
2583
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2584
          while (h->root.type == bfd_link_hash_indirect
2585
                 || h->root.type == bfd_link_hash_warning)
2586
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
2587
        }
2588
 
2589
      r_type = ELF32_R_TYPE (rel->r_info);
2590
      switch (r_type)
2591
        {
2592
        case R_CRIS_32_GOT:
2593
        case R_CRIS_16_GOT:
2594
        case R_CRIS_16_GOTPLT:
2595
        case R_CRIS_32_GOTPLT:
2596
          specific_refcount = h != NULL
2597
            ? &((struct elf_cris_link_hash_entry *) h)->reg_got_refcount
2598
            : &local_got_refcounts[LGOT_REG_NDX (r_symndx)];
2599
          break;
2600
 
2601
        case R_CRIS_32_GD:
2602
        case R_CRIS_32_GOT_GD:
2603
        case R_CRIS_16_GOT_GD:
2604
          got_element_size = 8;
2605
          specific_refcount = h != NULL
2606
            ? &((struct elf_cris_link_hash_entry *) h)->dtp_refcount
2607
            : &local_got_refcounts[LGOT_DTP_NDX (r_symndx)];
2608
          break;
2609
 
2610
        case R_CRIS_32_IE:
2611
        case R_CRIS_16_GOT_TPREL:
2612
        case R_CRIS_32_GOT_TPREL:
2613
          specific_refcount = h != NULL
2614
            ? &((struct elf_cris_link_hash_entry *) h)->tprel_refcount
2615
            : &local_got_refcounts[LGOT_TPREL_NDX (r_symndx)];
2616
          break;
2617
 
2618
        default:
2619
          break;
2620
        }
2621
 
2622
      switch (r_type)
2623
        {
2624
        case R_CRIS_32_IE:
2625
        case R_CRIS_32_GD:
2626
        case R_CRIS_16_GOT_TPREL:
2627
        case R_CRIS_32_GOT_TPREL:
2628
        case R_CRIS_32_GOT_GD:
2629
        case R_CRIS_16_GOT_GD:
2630
        case R_CRIS_16_GOT:
2631
        case R_CRIS_32_GOT:
2632
          if (h != NULL)
2633
            {
2634
              /* If the counters are 0 when we got here, we've
2635
                 miscounted somehow somewhere, an internal error.  */
2636
              BFD_ASSERT (h->got.refcount > 0);
2637
              --h->got.refcount;
2638
 
2639
              BFD_ASSERT (*specific_refcount > 0);
2640
              --*specific_refcount;
2641
              if (*specific_refcount == 0)
2642
                {
2643
                  /* We don't need the .got entry any more.  */
2644
                  sgot->size -= got_element_size;
2645
                  srelgot->size -= sizeof (Elf32_External_Rela);
2646
                }
2647
              break;
2648
            }
2649
 
2650
        local_got_reloc:
2651
          if (local_got_refcounts != NULL)
2652
            {
2653
              /* If the counters are 0 when we got here, we've
2654
                 miscounted somehow somewhere, an internal error.  */
2655
              BFD_ASSERT (local_got_refcounts[r_symndx] > 0);
2656
              --local_got_refcounts[r_symndx];
2657
 
2658
              BFD_ASSERT (*specific_refcount > 0);
2659
              --*specific_refcount;
2660
              if (*specific_refcount == 0)
2661
                {
2662
                  /* We don't need the .got entry any more.  */
2663
                  sgot->size -= got_element_size;
2664
                  if (info->shared)
2665
                    srelgot->size -= sizeof (Elf32_External_Rela);
2666
                }
2667
            }
2668
          break;
2669
 
2670
        case R_CRIS_16_GOTPLT:
2671
        case R_CRIS_32_GOTPLT:
2672
          /* For local symbols, treat these like GOT relocs.  */
2673
          if (h == NULL)
2674
            goto local_got_reloc;
2675
          /* Fall through.  */
2676
 
2677
        case R_CRIS_32_PLT_GOTREL:
2678
          /* FIXME: We don't garbage-collect away the .got section.  */
2679
          if (local_got_refcounts != NULL)
2680
            local_got_refcounts[-1]--;
2681
          /* Fall through.  */
2682
 
2683
        case R_CRIS_8_PCREL:
2684
        case R_CRIS_16_PCREL:
2685
        case R_CRIS_32_PCREL:
2686
        case R_CRIS_32_PLT_PCREL:
2687
          if (h != NULL)
2688
            {
2689
              if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2690
                  && h->plt.refcount > 0)
2691
                --h->plt.refcount;
2692
            }
2693
          break;
2694
 
2695
        case R_CRIS_32_DTPREL:
2696
          /* This'd be a .dtpreld entry in e.g. debug info.  */
2697
          if ((sec->flags & SEC_ALLOC) == 0)
2698
            break;
2699
          /* Fall through.  */
2700
        case R_CRIS_16_DTPREL:
2701
          htab->dtpmod_refcount--;
2702
          if (htab->dtpmod_refcount == 0)
2703
            htab->next_gotplt_entry -= 8;
2704
          BFD_ASSERT (local_got_refcounts != NULL);
2705
          local_got_refcounts[-1]--;
2706
          break;
2707
 
2708
        default:
2709
          break;
2710
        }
2711
    }
2712
 
2713
  return TRUE;
2714
}
2715
 
2716
/* The elf_backend_plt_sym_val hook function.  */
2717
 
2718
static bfd_vma
2719
cris_elf_plt_sym_val (bfd_vma i, const asection *plt,
2720
                      const arelent *rel ATTRIBUTE_UNUSED)
2721
{
2722
  bfd_size_type plt_entry_size;
2723
 
2724
  plt_entry_size
2725
    = (bfd_get_mach (plt->owner) == bfd_mach_cris_v32
2726
       ? PLT_ENTRY_SIZE_V32 : PLT_ENTRY_SIZE);
2727
 
2728
  return plt->vma + (i + 1) * plt_entry_size;
2729
}
2730
 
2731
/* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
2732
   entry but we found we will not create any.  Called when we find we will
2733
   not have any PLT for this symbol, by for example
2734
   elf_cris_adjust_dynamic_symbol when we're doing a proper dynamic link,
2735
   or elf_cris_size_dynamic_sections if no dynamic sections will be
2736
   created (we're only linking static objects).  */
2737
 
2738
static bfd_boolean
2739
elf_cris_adjust_gotplt_to_got (h, p)
2740
     struct elf_cris_link_hash_entry *h;
2741
     PTR p;
2742
{
2743
  struct bfd_link_info *info = (struct bfd_link_info *) p;
2744
 
2745
  if (h->root.root.type == bfd_link_hash_warning)
2746
    h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
2747
 
2748
  /* If nobody wanted a GOTPLT with this symbol, we're done.  */
2749
  if (h->gotplt_refcount <= 0)
2750
    return TRUE;
2751
 
2752
  if (h->reg_got_refcount > 0)
2753
    {
2754
      /* There's a GOT entry for this symbol.  Just adjust the refcounts.
2755
         Probably not necessary at this stage, but keeping them accurate
2756
         helps avoiding surprises later.  */
2757
      h->root.got.refcount += h->gotplt_refcount;
2758
      h->reg_got_refcount += h->gotplt_refcount;
2759
      h->gotplt_refcount = 0;
2760
    }
2761
  else
2762
    {
2763
      /* No GOT entry for this symbol.  We need to create one.  */
2764
      bfd *dynobj = elf_hash_table (info)->dynobj;
2765
      asection *sgot;
2766
      asection *srelgot;
2767
 
2768
      BFD_ASSERT (dynobj != NULL);
2769
      sgot = bfd_get_section_by_name (dynobj, ".got");
2770
      srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2771
 
2772
      /* Put accurate refcounts there.  */
2773
      h->root.got.refcount += h->gotplt_refcount;
2774
      h->reg_got_refcount = h->gotplt_refcount;
2775
 
2776
      h->gotplt_refcount = 0;
2777
 
2778
      /* We always have a .got and a .rela.got section if there were
2779
         GOTPLT relocs in input.  */
2780
      BFD_ASSERT (sgot != NULL && srelgot != NULL);
2781
 
2782
      /* Allocate space in the .got section.  */
2783
      sgot->size += 4;
2784
 
2785
      /* Allocate relocation space.  */
2786
      srelgot->size += sizeof (Elf32_External_Rela);
2787
    }
2788
 
2789
  return TRUE;
2790
}
2791
 
2792
/* Try to fold PLT entries with GOT entries.  There are two cases when we
2793
   want to do this:
2794
 
2795
   - When all PLT references are GOTPLT references, and there are GOT
2796
     references, and this is not the executable.  We don't have to
2797
     generate a PLT at all.
2798
 
2799
   - When there are both (ordinary) PLT references and GOT references,
2800
     and this isn't the executable.
2801
     We want to make the PLT reference use the ordinary GOT entry rather
2802
     than R_CRIS_JUMP_SLOT, a run-time dynamically resolved GOTPLT entry,
2803
     since the GOT entry will have to be resolved at startup anyway.
2804
 
2805
   Though the latter case is handled when room for the PLT is allocated,
2806
   not here.
2807
 
2808
   By folding into the GOT, we may need a round-trip to a PLT in the
2809
   executable for calls, a loss in performance.  Still, losing a
2810
   reloc is a win in size and at least in start-up time.
2811
 
2812
   Note that this function is called before symbols are forced local by
2813
   version scripts.  The differing cases are handled by
2814
   elf_cris_hide_symbol.  */
2815
 
2816
static bfd_boolean
2817
elf_cris_try_fold_plt_to_got (h, p)
2818
     struct elf_cris_link_hash_entry *h;
2819
     PTR p;
2820
{
2821
  struct bfd_link_info *info = (struct bfd_link_info *) p;
2822
 
2823
  /* If there are no GOT references for this symbol, we can't fold any
2824
     other reference so there's nothing to do.  Likewise if there are no
2825
     PLT references; GOTPLT references included.  */
2826
  if (h->root.got.refcount <= 0 || h->root.plt.refcount <= 0)
2827
    return TRUE;
2828
 
2829
  /* GOTPLT relocs are supposed to be included into the PLT refcount.  */
2830
  BFD_ASSERT (h->gotplt_refcount <= h->root.plt.refcount);
2831
 
2832
  if (h->gotplt_refcount == h->root.plt.refcount)
2833
    {
2834
      /* The only PLT references are GOTPLT references, and there are GOT
2835
         references.  Convert PLT to GOT references.  */
2836
      if (! elf_cris_adjust_gotplt_to_got (h, info))
2837
        return FALSE;
2838
 
2839
      /* Clear the PLT references, so no PLT will be created.  */
2840
      h->root.plt.offset = (bfd_vma) -1;
2841
    }
2842
 
2843
  return TRUE;
2844
}
2845
 
2846
/* Our own version of hide_symbol, so that we can adjust a GOTPLT reloc
2847
   to use a GOT entry (and create one) rather than requiring a GOTPLT
2848
   entry.  */
2849
 
2850
static void
2851
elf_cris_hide_symbol (info, h, force_local)
2852
     struct bfd_link_info *info;
2853
     struct elf_link_hash_entry *h;
2854
     bfd_boolean force_local;
2855
{
2856
  elf_cris_adjust_gotplt_to_got ((struct elf_cris_link_hash_entry *) h, info);
2857
 
2858
  _bfd_elf_link_hash_hide_symbol (info, h, force_local);
2859
}
2860
 
2861
/* Adjust a symbol defined by a dynamic object and referenced by a
2862
   regular object.  The current definition is in some section of the
2863
   dynamic object, but we're not including those sections.  We have to
2864
   change the definition to something the rest of the link can
2865
   understand.  */
2866
 
2867
static bfd_boolean
2868
elf_cris_adjust_dynamic_symbol (struct bfd_link_info *info,
2869
                                struct elf_link_hash_entry *h)
2870
{
2871
  struct elf_cris_link_hash_table * htab;
2872
  bfd *dynobj;
2873
  asection *s;
2874
  bfd_size_type plt_entry_size;
2875
 
2876
  htab = elf_cris_hash_table (info);
2877
  if (htab == NULL)
2878
    return FALSE;
2879
 
2880
  dynobj = elf_hash_table (info)->dynobj;
2881
 
2882
  /* Make sure we know what is going on here.  */
2883
  BFD_ASSERT (dynobj != NULL
2884
              && (h->needs_plt
2885
                  || h->u.weakdef != NULL
2886
                  || (h->def_dynamic
2887
                      && h->ref_regular
2888
                      && !h->def_regular)));
2889
 
2890
  plt_entry_size
2891
    = (bfd_get_mach (dynobj) == bfd_mach_cris_v32
2892
       ? PLT_ENTRY_SIZE_V32 : PLT_ENTRY_SIZE);
2893
 
2894
  /* If this is a function, put it in the procedure linkage table.  We
2895
     will fill in the contents of the procedure linkage table later,
2896
     when we know the address of the .got section.  */
2897
  if (h->type == STT_FUNC
2898
      || h->needs_plt)
2899
    {
2900
      /* If we link a program (not a DSO), we'll get rid of unnecessary
2901
         PLT entries; we point to the actual symbols -- even for pic
2902
         relocs, because a program built with -fpic should have the same
2903
         result as one built without -fpic, specifically considering weak
2904
         symbols.
2905
         FIXME: m68k and i386 differ here, for unclear reasons.  */
2906
      if (! info->shared
2907
          && !h->def_dynamic)
2908
        {
2909
          /* This case can occur if we saw a PLT reloc in an input file,
2910
             but the symbol was not defined by a dynamic object.  In such
2911
             a case, we don't actually need to build a procedure linkage
2912
             table, and we can just do an absolute or PC reloc instead, or
2913
             change a .got.plt index to a .got index for GOTPLT relocs.  */
2914
          BFD_ASSERT (h->needs_plt);
2915
          h->needs_plt = 0;
2916
          h->plt.offset = (bfd_vma) -1;
2917
          return
2918
            elf_cris_adjust_gotplt_to_got ((struct
2919
                                            elf_cris_link_hash_entry *) h,
2920
                                           info);
2921
        }
2922
 
2923
      /* If we had a R_CRIS_GLOB_DAT that didn't have to point to a PLT;
2924
         where a pointer-equivalent symbol was unimportant (i.e. more
2925
         like R_CRIS_JUMP_SLOT after symbol evaluation) we could get rid
2926
         of the PLT.  We can't for the executable, because the GOT
2927
         entries will point to the PLT there (and be constant).  */
2928
      if (info->shared
2929
          && !elf_cris_try_fold_plt_to_got ((struct elf_cris_link_hash_entry*)
2930
                                            h, info))
2931
        return FALSE;
2932
 
2933
      /* GC or folding may have rendered this entry unused.  */
2934
      if (h->plt.refcount <= 0)
2935
        {
2936
          h->needs_plt = 0;
2937
          h->plt.offset = (bfd_vma) -1;
2938
          return TRUE;
2939
        }
2940
 
2941
      /* Make sure this symbol is output as a dynamic symbol.  */
2942
      if (h->dynindx == -1)
2943
        {
2944
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
2945
            return FALSE;
2946
        }
2947
 
2948
      s = bfd_get_section_by_name (dynobj, ".plt");
2949
      BFD_ASSERT (s != NULL);
2950
 
2951
      /* If this is the first .plt entry, make room for the special
2952
         first entry.  */
2953
      if (s->size == 0)
2954
        s->size += plt_entry_size;
2955
 
2956
      /* If this symbol is not defined in a regular file, and we are
2957
         not generating a shared library, then set the symbol to this
2958
         location in the .plt.  */
2959
      if (!info->shared
2960
          && !h->def_regular)
2961
        {
2962
          h->root.u.def.section = s;
2963
          h->root.u.def.value = s->size;
2964
        }
2965
 
2966
      /* If there's already a GOT entry, use that, not a .got.plt.  A
2967
         GOT field still has a reference count when we get here; it's
2968
         not yet changed to an offset.  We can't do this for an
2969
         executable, because then the reloc associated with the PLT
2970
         would get a non-PLT reloc pointing to the PLT.  FIXME: Move
2971
         this to elf_cris_try_fold_plt_to_got.  */
2972
      if (info->shared && h->got.refcount > 0)
2973
        {
2974
          h->got.refcount += h->plt.refcount;
2975
 
2976
          /* Mark the PLT offset to use the GOT entry by setting the low
2977
             bit in the plt offset; it is always a multiple of
2978
             plt_entry_size (which is at least a multiple of 2).  */
2979
          BFD_ASSERT ((s->size % plt_entry_size) == 0);
2980
 
2981
          /* Change the PLT refcount to an offset.  */
2982
          h->plt.offset = s->size;
2983
 
2984
          /* By not setting gotplt_offset (i.e. it remains at 0), we signal
2985
             that the got entry should be used instead.  */
2986
          BFD_ASSERT (((struct elf_cris_link_hash_entry *)
2987
                       h)->gotplt_offset == 0);
2988
 
2989
          /* Make room for this entry.  */
2990
          s->size += plt_entry_size;
2991
 
2992
          return TRUE;
2993
        }
2994
 
2995
      /* No GOT reference for this symbol; prepare for an ordinary PLT.  */
2996
      h->plt.offset = s->size;
2997
 
2998
      /* Make room for this entry.  */
2999
      s->size += plt_entry_size;
3000
 
3001
      /* We also need to make an entry in the .got.plt section, which
3002
         will be placed in the .got section by the linker script.  */
3003
      ((struct elf_cris_link_hash_entry *) h)->gotplt_offset
3004
        = htab->next_gotplt_entry;
3005
      htab->next_gotplt_entry += 4;
3006
 
3007
      s = bfd_get_section_by_name (dynobj, ".got.plt");
3008
      BFD_ASSERT (s != NULL);
3009
      s->size += 4;
3010
 
3011
      /* We also need to make an entry in the .rela.plt section.  */
3012
 
3013
      s = bfd_get_section_by_name (dynobj, ".rela.plt");
3014
      BFD_ASSERT (s != NULL);
3015
      s->size += sizeof (Elf32_External_Rela);
3016
 
3017
      return TRUE;
3018
    }
3019
 
3020
  /* Reinitialize the plt offset now that it is not used as a reference
3021
     count any more.  */
3022
  h->plt.offset = (bfd_vma) -1;
3023
 
3024
  /* If this is a weak symbol, and there is a real definition, the
3025
     processor independent code will have arranged for us to see the
3026
     real definition first, and we can just use the same value.  */
3027
  if (h->u.weakdef != NULL)
3028
    {
3029
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3030
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
3031
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
3032
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
3033
      return TRUE;
3034
    }
3035
 
3036
  /* This is a reference to a symbol defined by a dynamic object which
3037
     is not a function.  */
3038
 
3039
  /* If we are creating a shared library, we must presume that the
3040
     only references to the symbol are via the global offset table.
3041
     For such cases we need not do anything here; the relocations will
3042
     be handled correctly by relocate_section.  */
3043
  if (info->shared)
3044
    return TRUE;
3045
 
3046
  /* If there are no references to this symbol that do not use the
3047
     GOT, we don't need to generate a copy reloc.  */
3048
  if (!h->non_got_ref)
3049
    return TRUE;
3050
 
3051
  if (h->size == 0)
3052
    {
3053
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
3054
                             h->root.root.string);
3055
      return TRUE;
3056
    }
3057
 
3058
  /* We must allocate the symbol in our .dynbss section, which will
3059
     become part of the .bss section of the executable.  There will be
3060
     an entry for this symbol in the .dynsym section.  The dynamic
3061
     object will contain position independent code, so all references
3062
     from the dynamic object to this symbol will go through the global
3063
     offset table.  The dynamic linker will use the .dynsym entry to
3064
     determine the address it must put in the global offset table, so
3065
     both the dynamic object and the regular object will refer to the
3066
     same memory location for the variable.  */
3067
 
3068
  s = bfd_get_section_by_name (dynobj, ".dynbss");
3069
  BFD_ASSERT (s != NULL);
3070
 
3071
  /* We must generate a R_CRIS_COPY reloc to tell the dynamic linker to
3072
     copy the initial value out of the dynamic object and into the
3073
     runtime process image.  We need to remember the offset into the
3074
     .rela.bss section we are going to use.  */
3075
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3076
    {
3077
      asection *srel;
3078
 
3079
      srel = bfd_get_section_by_name (dynobj, ".rela.bss");
3080
      BFD_ASSERT (srel != NULL);
3081
      srel->size += sizeof (Elf32_External_Rela);
3082
      h->needs_copy = 1;
3083
    }
3084
 
3085
  return _bfd_elf_adjust_dynamic_copy (h, s);
3086
}
3087
 
3088
/* Adjust our "subclass" elements for an indirect symbol.  */
3089
 
3090
static void
3091
elf_cris_copy_indirect_symbol (struct bfd_link_info *info,
3092
                               struct elf_link_hash_entry *dir,
3093
                               struct elf_link_hash_entry *ind)
3094
{
3095
  struct elf_cris_link_hash_entry *edir, *eind;
3096
 
3097
  edir = (struct elf_cris_link_hash_entry *) dir;
3098
  eind = (struct elf_cris_link_hash_entry *) ind;
3099
 
3100
  /* Only indirect symbols are replaced; we're not interested in
3101
     updating any of EIND's fields for other symbols.  */
3102
  if (eind->root.root.type != bfd_link_hash_indirect)
3103
    {
3104
      /* Still, we need to copy flags for e.g. weak definitions.  */
3105
      _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3106
      return;
3107
    }
3108
 
3109
  BFD_ASSERT (edir->pcrel_relocs_copied == NULL);
3110
  BFD_ASSERT (edir->gotplt_offset == 0 || eind->gotplt_offset == 0);
3111
 
3112
#define XMOVOPZ(F, OP, Z) edir->F OP eind->F; eind->F = Z
3113
#define XMOVE(F) XMOVOPZ (F, +=, 0)
3114
  XMOVOPZ (pcrel_relocs_copied, =, NULL);
3115
  XMOVE (gotplt_refcount);
3116
  XMOVE (gotplt_offset);
3117
  XMOVE (reg_got_refcount);
3118
  XMOVE (tprel_refcount);
3119
  XMOVE (dtp_refcount);
3120
#undef XMOVE
3121
#undef XMOVOPZ
3122
 
3123
  _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3124
}
3125
 
3126
/* Look through the relocs for a section during the first phase.  */
3127
 
3128
static bfd_boolean
3129
cris_elf_check_relocs (bfd *abfd,
3130
                       struct bfd_link_info *info,
3131
                       asection *sec,
3132
                       const Elf_Internal_Rela *relocs)
3133
{
3134
  struct elf_cris_link_hash_table * htab;
3135
  bfd *dynobj;
3136
  Elf_Internal_Shdr *symtab_hdr;
3137
  struct elf_link_hash_entry **sym_hashes;
3138
  bfd_signed_vma *local_got_refcounts;
3139
  const Elf_Internal_Rela *rel;
3140
  const Elf_Internal_Rela *rel_end;
3141
  asection *sgot;
3142
  asection *srelgot;
3143
  asection *sreloc;
3144
 
3145
  if (info->relocatable)
3146
    return TRUE;
3147
 
3148
  htab = elf_cris_hash_table (info);
3149
  if (htab == NULL)
3150
    return FALSE;
3151
 
3152
  dynobj = elf_hash_table (info)->dynobj;
3153
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3154
  sym_hashes = elf_sym_hashes (abfd);
3155
  local_got_refcounts = elf_local_got_refcounts (abfd);
3156
 
3157
  sgot = NULL;
3158
  srelgot = NULL;
3159
  sreloc = NULL;
3160
 
3161
  rel_end = relocs + sec->reloc_count;
3162
  for (rel = relocs; rel < rel_end; rel++)
3163
    {
3164
      struct elf_link_hash_entry *h;
3165
      unsigned long r_symndx;
3166
      enum elf_cris_reloc_type r_type;
3167
      bfd_signed_vma got_element_size = 4;
3168
      unsigned long r_symndx_lgot = INT_MAX;
3169
 
3170
      r_symndx = ELF32_R_SYM (rel->r_info);
3171
      if (r_symndx < symtab_hdr->sh_info)
3172
        {
3173
          h = NULL;
3174
          r_symndx_lgot = LGOT_REG_NDX (r_symndx);
3175
        }
3176
      else
3177
        {
3178
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3179
          while (h->root.type == bfd_link_hash_indirect
3180
                 || h->root.type == bfd_link_hash_warning)
3181
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
3182
        }
3183
 
3184
      r_type = ELF32_R_TYPE (rel->r_info);
3185
 
3186
      /* Some relocs require linker-created sections; we need to hang them
3187
         on the first input bfd we found that contained dynamic relocs.  */
3188
      switch (r_type)
3189
        {
3190
        case R_CRIS_32_DTPREL:
3191
          if ((sec->flags & SEC_ALLOC) == 0)
3192
            /* This'd be a .dtpreld entry in e.g. debug info.  We have
3193
               several different switch statements below, but none of
3194
               that is needed; we need no preparations for resolving
3195
               R_CRIS_32_DTPREL into a non-allocated section (debug
3196
               info), so let's just move on to the next
3197
               relocation.  */
3198
            continue;
3199
          /* Fall through.  */
3200
        case R_CRIS_16_DTPREL:
3201
          /* The first .got.plt entry is right after the R_CRIS_DTPMOD
3202
             entry at index 3. */
3203
          if (htab->dtpmod_refcount == 0)
3204
            htab->next_gotplt_entry += 8;
3205
 
3206
          htab->dtpmod_refcount++;
3207
          /* Fall through.  */
3208
 
3209
        case R_CRIS_32_IE:
3210
        case R_CRIS_32_GD:
3211
        case R_CRIS_16_GOT_GD:
3212
        case R_CRIS_32_GOT_GD:
3213
        case R_CRIS_32_GOT_TPREL:
3214
        case R_CRIS_16_GOT_TPREL:
3215
        case R_CRIS_16_GOT:
3216
        case R_CRIS_32_GOT:
3217
        case R_CRIS_32_GOTREL:
3218
        case R_CRIS_32_PLT_GOTREL:
3219
        case R_CRIS_32_PLT_PCREL:
3220
        case R_CRIS_16_GOTPLT:
3221
        case R_CRIS_32_GOTPLT:
3222
          if (dynobj == NULL)
3223
            {
3224
              elf_hash_table (info)->dynobj = dynobj = abfd;
3225
 
3226
              /* We could handle this if we can get a handle on the
3227
                 output bfd in elf_cris_adjust_dynamic_symbol.  Failing
3228
                 that, we must insist on dynobj being a specific mach.  */
3229
              if (bfd_get_mach (dynobj) == bfd_mach_cris_v10_v32)
3230
                {
3231
                  (*_bfd_error_handler)
3232
                    (_("%B, section %A:\n  v10/v32 compatible object %s"
3233
                       " must not contain a PIC relocation"),
3234
                     abfd, sec);
3235
                  return FALSE;
3236
                }
3237
 
3238
              /* Create the .got section, so we can assume it's always
3239
                 present whenever there's a dynobj.  */
3240
              if (!_bfd_elf_create_got_section (dynobj, info))
3241
                return FALSE;
3242
            }
3243
 
3244
          if (sgot == NULL)
3245
            sgot = bfd_get_section_by_name (dynobj, ".got");
3246
 
3247
          if (local_got_refcounts == NULL)
3248
            {
3249
              bfd_size_type amt;
3250
 
3251
              /* We use index local_got_refcounts[-1] to count all
3252
                 GOT-relative relocations that do not have explicit
3253
                 GOT entries.  */
3254
              amt = LGOT_ALLOC_NELTS_FOR (symtab_hdr->sh_info) + 1;
3255
              amt *= sizeof (bfd_signed_vma);
3256
              local_got_refcounts = ((bfd_signed_vma *) bfd_zalloc (abfd, amt));
3257
              if (local_got_refcounts == NULL)
3258
                return FALSE;
3259
 
3260
              local_got_refcounts++;
3261
              elf_local_got_refcounts (abfd) = local_got_refcounts;
3262
            }
3263
          break;
3264
 
3265
        default:
3266
          break;
3267
        }
3268
 
3269
      /* Some relocs require a global offset table (but perhaps not a
3270
         specific GOT entry).  */
3271
      switch (r_type)
3272
        {
3273
        case R_CRIS_16_DTPREL:
3274
        case R_CRIS_32_DTPREL:
3275
          /* Not requesting .got.rela for an executable: the contents
3276
             of the first entry is constant there.  For a shared
3277
             library, we need .got.rela for the R_CRIS_DTPMOD
3278
             relocation at index 3.  */
3279
          if (!info->shared)
3280
            break;
3281
          /* Fall through.  */
3282
 
3283
        case R_CRIS_32_IE:
3284
        case R_CRIS_32_GD:
3285
        case R_CRIS_16_GOT_GD:
3286
        case R_CRIS_32_GOT_GD:
3287
        case R_CRIS_32_GOT_TPREL:
3288
        case R_CRIS_16_GOT_TPREL:
3289
          /* Fall through.  */
3290
 
3291
          /* For R_CRIS_16_GOTPLT and R_CRIS_32_GOTPLT, we need a GOT
3292
             entry only for local symbols.  Unfortunately, we don't know
3293
             until later on if there's a version script that forces the
3294
             symbol local.  We must have the .rela.got section in place
3295
             before we know if the symbol looks global now, so we need
3296
             to treat the reloc just like for R_CRIS_16_GOT and
3297
             R_CRIS_32_GOT.  */
3298
        case R_CRIS_16_GOTPLT:
3299
        case R_CRIS_32_GOTPLT:
3300
        case R_CRIS_16_GOT:
3301
        case R_CRIS_32_GOT:
3302
          if (srelgot == NULL
3303
              && (h != NULL || info->shared))
3304
            {
3305
              srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3306
              if (srelgot == NULL)
3307
                {
3308
                  srelgot = bfd_make_section_with_flags (dynobj,
3309
                                                         ".rela.got",
3310
                                                         (SEC_ALLOC
3311
                                                          | SEC_LOAD
3312
                                                          | SEC_HAS_CONTENTS
3313
                                                          | SEC_IN_MEMORY
3314
                                                          | SEC_LINKER_CREATED
3315
                                                          | SEC_READONLY));
3316
                  if (srelgot == NULL
3317
                      || !bfd_set_section_alignment (dynobj, srelgot, 2))
3318
                    return FALSE;
3319
                }
3320
            }
3321
          break;
3322
 
3323
        default:
3324
          break;
3325
        }
3326
 
3327
      /* Warn and error for invalid input.  */
3328
      switch (r_type)
3329
        {
3330
        case R_CRIS_32_IE:
3331
        case R_CRIS_32_TPREL:
3332
        case R_CRIS_16_TPREL:
3333
        case R_CRIS_32_GD:
3334
          if (info->shared)
3335
            {
3336
              (*_bfd_error_handler)
3337
                (_("%B, section %A:\n  relocation %s not valid"
3338
                   " in a shared object;"
3339
                   " typically an option mixup, recompile with -fPIC"),
3340
                 abfd,
3341
                 sec,
3342
                 cris_elf_howto_table[r_type].name);
3343
              /* Don't return FALSE here; we want messages for all of
3344
                 these and the error behavior is ungraceful
3345
                 anyway.  */
3346
            }
3347
        default:
3348
          break;
3349
        }
3350
 
3351
      switch (r_type)
3352
        {
3353
        case R_CRIS_32_GD:
3354
        case R_CRIS_16_GOT_GD:
3355
        case R_CRIS_32_GOT_GD:
3356
          /* These are requests for tls_index entries, run-time R_CRIS_DTP.  */
3357
          got_element_size = 8;
3358
          r_symndx_lgot = LGOT_DTP_NDX (r_symndx);
3359
          break;
3360
 
3361
        case R_CRIS_16_DTPREL:
3362
        case R_CRIS_32_DTPREL:
3363
          /* These two just request for the constant-index
3364
             module-local tls_index-sized GOT entry, which we add
3365
             elsewhere.  */
3366
          break;
3367
 
3368
        case R_CRIS_32_IE:
3369
        case R_CRIS_32_GOT_TPREL:
3370
        case R_CRIS_16_GOT_TPREL:
3371
          r_symndx_lgot = LGOT_TPREL_NDX (r_symndx);
3372
 
3373
          /* Those relocs also require that a DSO is of type
3374
             Initial Exec.  Like other targets, we don't reset this
3375
             flag even if the relocs are GC:ed away.  */
3376
          if (info->shared)
3377
            info->flags |= DF_STATIC_TLS;
3378
          break;
3379
 
3380
          /* Let's list the other assembler-generated TLS-relocs too,
3381
             just to show that they're not forgotten. */
3382
        case R_CRIS_16_TPREL:
3383
        case R_CRIS_32_TPREL:
3384
        default:
3385
          break;
3386
        }
3387
 
3388
      switch (r_type)
3389
        {
3390
        case R_CRIS_16_GOTPLT:
3391
        case R_CRIS_32_GOTPLT:
3392
          /* Mark that we need a GOT entry if the PLT entry (and its GOT
3393
             entry) is eliminated.  We can only do this for a non-local
3394
             symbol.  */
3395
          if (h != NULL)
3396
            {
3397
              elf_cris_hash_entry (h)->gotplt_refcount++;
3398
              goto handle_gotplt_reloc;
3399
            }
3400
          /* If h is NULL then this is a local symbol, and we must make a
3401
             GOT entry for it, so handle it like a GOT reloc.  */
3402
          /* Fall through.  */
3403
 
3404
        case R_CRIS_32_IE:
3405
        case R_CRIS_32_GD:
3406
        case R_CRIS_16_GOT_GD:
3407
        case R_CRIS_32_GOT_GD:
3408
        case R_CRIS_32_GOT_TPREL:
3409
        case R_CRIS_16_GOT_TPREL:
3410
        case R_CRIS_16_GOT:
3411
        case R_CRIS_32_GOT:
3412
          /* This symbol requires a global offset table entry.  */
3413
          if (h != NULL)
3414
            {
3415
              if (h->got.refcount == 0)
3416
                {
3417
                  /* Make sure this symbol is output as a dynamic symbol.  */
3418
                  if (h->dynindx == -1)
3419
                    {
3420
                      if (!bfd_elf_link_record_dynamic_symbol (info, h))
3421
                        return FALSE;
3422
                    }
3423
                }
3424
 
3425
              /* Update the sum of reloc counts for this symbol.  */
3426
              h->got.refcount++;
3427
 
3428
              switch (r_type)
3429
                {
3430
                case R_CRIS_16_GOT:
3431
                case R_CRIS_32_GOT:
3432
                  if (elf_cris_hash_entry (h)->reg_got_refcount == 0)
3433
                    {
3434
                      /* Allocate space in the .got section.  */
3435
                      sgot->size += got_element_size;
3436
                      /* Allocate relocation space.  */
3437
                      srelgot->size += sizeof (Elf32_External_Rela);
3438
                    }
3439
                  elf_cris_hash_entry (h)->reg_got_refcount++;
3440
                  break;
3441
 
3442
                case R_CRIS_32_GD:
3443
                case R_CRIS_16_GOT_GD:
3444
                case R_CRIS_32_GOT_GD:
3445
                  if (elf_cris_hash_entry (h)->dtp_refcount == 0)
3446
                    {
3447
                      /* Allocate space in the .got section.  */
3448
                      sgot->size += got_element_size;
3449
                      /* Allocate relocation space.  */
3450
                      srelgot->size += sizeof (Elf32_External_Rela);
3451
                    }
3452
                  elf_cris_hash_entry (h)->dtp_refcount++;
3453
                  break;
3454
 
3455
                case R_CRIS_32_IE:
3456
                case R_CRIS_32_GOT_TPREL:
3457
                case R_CRIS_16_GOT_TPREL:
3458
                  if (elf_cris_hash_entry (h)->tprel_refcount == 0)
3459
                    {
3460
                      /* Allocate space in the .got section.  */
3461
                      sgot->size += got_element_size;
3462
                      /* Allocate relocation space.  */
3463
                      srelgot->size += sizeof (Elf32_External_Rela);
3464
                    }
3465
                  elf_cris_hash_entry (h)->tprel_refcount++;
3466
                  break;
3467
 
3468
                default:
3469
                  BFD_FAIL ();
3470
                  break;
3471
                }
3472
            }
3473
          else
3474
            {
3475
              /* This is a global offset table entry for a local symbol.  */
3476
              if (local_got_refcounts[r_symndx_lgot] == 0)
3477
                {
3478
                  sgot->size += got_element_size;
3479
                  if (info->shared)
3480
                    {
3481
                      /* If we are generating a shared object, we need
3482
                         to output a R_CRIS_RELATIVE reloc so that the
3483
                         dynamic linker can adjust this GOT entry.
3484
                         Similarly for non-regular got entries.  */
3485
                      srelgot->size += sizeof (Elf32_External_Rela);
3486
                    }
3487
                }
3488
              /* Update the reloc-specific count.  */
3489
              local_got_refcounts[r_symndx_lgot]++;
3490
 
3491
              /* This one is the sum of all the others.  */
3492
              local_got_refcounts[r_symndx]++;
3493
            }
3494
          break;
3495
 
3496
        case R_CRIS_16_DTPREL:
3497
        case R_CRIS_32_DTPREL:
3498
        case R_CRIS_32_GOTREL:
3499
          /* This reference requires a global offset table.
3500
             FIXME: The actual refcount isn't used currently; the .got
3501
             section can't be removed if there were any references in the
3502
             input.  */
3503
          local_got_refcounts[-1]++;
3504
          break;
3505
 
3506
        handle_gotplt_reloc:
3507
 
3508
        case R_CRIS_32_PLT_GOTREL:
3509
          /* This reference requires a global offset table.  */
3510
          local_got_refcounts[-1]++;
3511
          /* Fall through.  */
3512
 
3513
        case R_CRIS_32_PLT_PCREL:
3514
          /* This symbol requires a procedure linkage table entry.  We
3515
             actually build the entry in adjust_dynamic_symbol,
3516
             because this might be a case of linking PIC code which is
3517
             never referenced by a dynamic object, in which case we
3518
             don't need to generate a procedure linkage table entry
3519
             after all.  */
3520
 
3521
          /* Beware: if we'd check for visibility of the symbol here
3522
             (and not marking the need for a PLT when non-visible), we'd
3523
             get into trouble with keeping handling consistent with
3524
             regards to relocs found before definition and GOTPLT
3525
             handling.  Eliminable PLT entries will be dealt with later
3526
             anyway.  */
3527
          if (h == NULL)
3528
            continue;
3529
 
3530
          h->needs_plt = 1;
3531
          h->plt.refcount++;
3532
          break;
3533
 
3534
        case R_CRIS_8:
3535
        case R_CRIS_16:
3536
        case R_CRIS_32:
3537
          /* Let's help debug shared library creation.  Any of these
3538
             relocs *can* be used in shared libs, but pages containing
3539
             them cannot be shared, so they're not appropriate for
3540
             common use.  Don't warn for sections we don't care about,
3541
             such as debug sections or non-constant sections.  We
3542
             can't help tables of (global) function pointers, for
3543
             example, though they must be emitted in a (writable) data
3544
             section to avoid having impure text sections.  */
3545
          if (info->shared
3546
              && (sec->flags & SEC_ALLOC) != 0
3547
              && (sec->flags & SEC_READONLY) != 0)
3548
            {
3549
              /* FIXME: How do we make this optionally a warning only?  */
3550
              (*_bfd_error_handler)
3551
                (_("%B, section %A:\n  relocation %s should not"
3552
                   " be used in a shared object; recompile with -fPIC"),
3553
                 abfd,
3554
                 sec,
3555
                 cris_elf_howto_table[r_type].name);
3556
            }
3557
          if (h != NULL)
3558
            {
3559
              h->non_got_ref = 1;
3560
 
3561
              /* Make sure a plt entry is created for this symbol if it
3562
                 turns out to be a function defined by a dynamic object.  */
3563
              if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3564
                h->plt.refcount++;
3565
            }
3566
 
3567
          /* If we are creating a shared library and this is not a local
3568
             symbol, we need to copy the reloc into the shared library.
3569
             However when linking with -Bsymbolic and this is a global
3570
             symbol which is defined in an object we are including in the
3571
             link (i.e., DEF_REGULAR is set), then we can resolve the
3572
             reloc directly.  At this point we have not seen all the input
3573
             files, so it is possible that DEF_REGULAR is not set now but
3574
             will be set later (it is never cleared).  In case of a weak
3575
             definition, DEF_REGULAR may be cleared later by a strong
3576
             definition in a shared library.  We account for that
3577
             possibility below by storing information in the relocs_copied
3578
             field of the hash table entry.  A similar situation occurs
3579
             when creating shared libraries and symbol visibility changes
3580
             render the symbol local.  */
3581
 
3582
          /* No need to do anything if we're not creating a shared object.  */
3583
          if (! info->shared)
3584
            break;
3585
 
3586
          /* We don't need to handle relocs into sections not going into
3587
             the "real" output.  */
3588
          if ((sec->flags & SEC_ALLOC) == 0)
3589
            break;
3590
 
3591
          /* We may need to create a reloc section in the dynobj and made room
3592
             for this reloc.  */
3593
          if (sreloc == NULL)
3594
            {
3595
              sreloc = _bfd_elf_make_dynamic_reloc_section
3596
                (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3597
 
3598
              if (sreloc == NULL)
3599
                return FALSE;
3600
            }
3601
 
3602
          if (sec->flags & SEC_READONLY)
3603
            info->flags |= DF_TEXTREL;
3604
 
3605
          sreloc->size += sizeof (Elf32_External_Rela);
3606
          break;
3607
 
3608
        case R_CRIS_8_PCREL:
3609
        case R_CRIS_16_PCREL:
3610
        case R_CRIS_32_PCREL:
3611
          if (h != NULL)
3612
            {
3613
              h->non_got_ref = 1;
3614
 
3615
              /* Make sure a plt entry is created for this symbol if it
3616
                 turns out to be a function defined by a dynamic object.  */
3617
              if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3618
                h->plt.refcount++;
3619
            }
3620
 
3621
          /* If we are creating a shared library and this is not a local
3622
             symbol, we need to copy the reloc into the shared library.
3623
             However when linking with -Bsymbolic and this is a global
3624
             symbol which is defined in an object we are including in the
3625
             link (i.e., DEF_REGULAR is set), then we can resolve the
3626
             reloc directly.  At this point we have not seen all the input
3627
             files, so it is possible that DEF_REGULAR is not set now but
3628
             will be set later (it is never cleared).  In case of a weak
3629
             definition, DEF_REGULAR may be cleared later by a strong
3630
             definition in a shared library.  We account for that
3631
             possibility below by storing information in the relocs_copied
3632
             field of the hash table entry.  A similar situation occurs
3633
             when creating shared libraries and symbol visibility changes
3634
             render the symbol local.  */
3635
 
3636
          /* No need to do anything if we're not creating a shared object.  */
3637
          if (! info->shared)
3638
            break;
3639
 
3640
          /* We don't need to handle relocs into sections not going into
3641
             the "real" output.  */
3642
          if ((sec->flags & SEC_ALLOC) == 0)
3643
            break;
3644
 
3645
          /* If the symbol is local, then we know already we can
3646
             eliminate the reloc.  */
3647
          if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3648
            break;
3649
 
3650
          /* If this is with -Bsymbolic and the symbol isn't weak, and
3651
             is defined by an ordinary object (the ones we include in
3652
             this shared library) then we can also eliminate the
3653
             reloc.  See comment above for more eliminable cases which
3654
             we can't identify at this time.  */
3655
          if (info->symbolic
3656
              && h->root.type != bfd_link_hash_defweak
3657
              && h->def_regular)
3658
            break;
3659
 
3660
          /* We may need to create a reloc section in the dynobj and made room
3661
             for this reloc.  */
3662
          if (sreloc == NULL)
3663
            {
3664
              sreloc = _bfd_elf_make_dynamic_reloc_section
3665
                (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3666
 
3667
              if (sreloc == NULL)
3668
                return FALSE;
3669
            }
3670
 
3671
          sreloc->size += sizeof (Elf32_External_Rela);
3672
 
3673
          /* We count the number of PC relative relocations we have
3674
             entered for this symbol, so that we can discard them
3675
             again if the symbol is later defined by a regular object.
3676
             We know that h is really a pointer to an
3677
             elf_cris_link_hash_entry.  */
3678
          {
3679
            struct elf_cris_link_hash_entry *eh;
3680
            struct elf_cris_pcrel_relocs_copied *p;
3681
 
3682
            eh = elf_cris_hash_entry (h);
3683
 
3684
            for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
3685
              if (p->section == sreloc)
3686
                break;
3687
 
3688
            if (p == NULL)
3689
              {
3690
                p = ((struct elf_cris_pcrel_relocs_copied *)
3691
                     bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
3692
                if (p == NULL)
3693
                  return FALSE;
3694
                p->next = eh->pcrel_relocs_copied;
3695
                eh->pcrel_relocs_copied = p;
3696
                p->section = sreloc;
3697
                p->count = 0;
3698
                p->r_type = r_type;
3699
              }
3700
 
3701
            ++p->count;
3702
          }
3703
          break;
3704
 
3705
        /* This relocation describes the C++ object vtable hierarchy.
3706
           Reconstruct it for later use during GC.  */
3707
        case R_CRIS_GNU_VTINHERIT:
3708
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3709
            return FALSE;
3710
          break;
3711
 
3712
        /* This relocation describes which C++ vtable entries are actually
3713
           used.  Record for later use during GC.  */
3714
        case R_CRIS_GNU_VTENTRY:
3715
          BFD_ASSERT (h != NULL);
3716
          if (h != NULL
3717
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3718
            return FALSE;
3719
          break;
3720
 
3721
        case R_CRIS_16_TPREL:
3722
        case R_CRIS_32_TPREL:
3723
          /* Already warned above, when necessary.  */
3724
          break;
3725
 
3726
        default:
3727
          /* Other relocs do not appear here.  */
3728
          bfd_set_error (bfd_error_bad_value);
3729
          return FALSE;
3730
        }
3731
    }
3732
 
3733
  return TRUE;
3734
}
3735
 
3736
/* Set the sizes of the dynamic sections.  */
3737
 
3738
static bfd_boolean
3739
elf_cris_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3740
                                struct bfd_link_info *info)
3741
{
3742
  struct elf_cris_link_hash_table * htab;
3743
  bfd *dynobj;
3744
  asection *s;
3745
  bfd_boolean plt;
3746
  bfd_boolean relocs;
3747
 
3748
  htab = elf_cris_hash_table (info);
3749
  if (htab == NULL)
3750
    return FALSE;
3751
 
3752
  dynobj = elf_hash_table (info)->dynobj;
3753
  BFD_ASSERT (dynobj != NULL);
3754
 
3755
  if (elf_hash_table (info)->dynamic_sections_created)
3756
    {
3757
      /* Set the contents of the .interp section to the interpreter.  */
3758
      if (info->executable)
3759
        {
3760
          s = bfd_get_section_by_name (dynobj, ".interp");
3761
          BFD_ASSERT (s != NULL);
3762
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3763
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3764
        }
3765
    }
3766
  else
3767
    {
3768
      /* Adjust all expected GOTPLT uses to use a GOT entry instead.  */
3769
      elf_cris_link_hash_traverse (htab, elf_cris_adjust_gotplt_to_got,
3770
                                   info);
3771
 
3772
      /* We may have created entries in the .rela.got section.
3773
         However, if we are not creating the dynamic sections, we will
3774
         not actually use these entries.  Reset the size of .rela.got,
3775
         which will cause it to get stripped from the output file
3776
         below.  */
3777
      s = bfd_get_section_by_name (dynobj, ".rela.got");
3778
      if (s != NULL)
3779
        s->size = 0;
3780
    }
3781
 
3782
  /* If this is a -Bsymbolic shared link, then we need to discard all PC
3783
     relative relocs against symbols defined in a regular object.  We
3784
     allocated space for them in the check_relocs routine, but we will not
3785
     fill them in in the relocate_section routine.  We also discard space
3786
     for relocs that have become for local symbols due to symbol
3787
     visibility changes.  For programs, we discard space for relocs for
3788
     symbols not referenced by any dynamic object.  */
3789
  if (info->shared)
3790
    elf_cris_link_hash_traverse (htab,
3791
                                 elf_cris_discard_excess_dso_dynamics,
3792
                                 info);
3793
  else
3794
    elf_cris_link_hash_traverse (htab,
3795
                                 elf_cris_discard_excess_program_dynamics,
3796
                                 info);
3797
 
3798
  /* The check_relocs and adjust_dynamic_symbol entry points have
3799
     determined the sizes of the various dynamic sections.  Allocate
3800
     memory for them.  */
3801
  plt = FALSE;
3802
  relocs = FALSE;
3803
  for (s = dynobj->sections; s != NULL; s = s->next)
3804
    {
3805
      const char *name;
3806
 
3807
      if ((s->flags & SEC_LINKER_CREATED) == 0)
3808
        continue;
3809
 
3810
      /* It's OK to base decisions on the section name, because none
3811
         of the dynobj section names depend upon the input files.  */
3812
      name = bfd_get_section_name (dynobj, s);
3813
 
3814
      if (strcmp (name, ".plt") == 0)
3815
        {
3816
          /* Remember whether there is a PLT.  */
3817
          plt = s->size != 0;
3818
        }
3819
      else if (strcmp (name, ".got.plt") == 0)
3820
        {
3821
          /* The .got.plt contains the .got header as well as the
3822
             actual .got.plt contents.  The .got header may contain a
3823
             R_CRIS_DTPMOD entry at index 3.  */
3824
          s->size += htab->dtpmod_refcount != 0
3825
            ? 8 : 0;
3826
        }
3827
      else if (CONST_STRNEQ (name, ".rela"))
3828
        {
3829
          if (strcmp (name, ".rela.got") == 0
3830
              && htab->dtpmod_refcount != 0
3831
              && info->shared)
3832
            s->size += sizeof (Elf32_External_Rela);
3833
 
3834
          if (s->size != 0)
3835
            {
3836
              /* Remember whether there are any reloc sections other
3837
                 than .rela.plt.  */
3838
              if (strcmp (name, ".rela.plt") != 0)
3839
                  relocs = TRUE;
3840
 
3841
              /* We use the reloc_count field as a counter if we need
3842
                 to copy relocs into the output file.  */
3843
              s->reloc_count = 0;
3844
            }
3845
        }
3846
      else if (! CONST_STRNEQ (name, ".got")
3847
               && strcmp (name, ".dynbss") != 0)
3848
        {
3849
          /* It's not one of our sections, so don't allocate space.  */
3850
          continue;
3851
        }
3852
 
3853
      if (s->size == 0)
3854
        {
3855
          /* If we don't need this section, strip it from the
3856
             output file.  This is mostly to handle .rela.bss and
3857
             .rela.plt.  We must create both sections in
3858
             create_dynamic_sections, because they must be created
3859
             before the linker maps input sections to output
3860
             sections.  The linker does that before
3861
             adjust_dynamic_symbol is called, and it is that
3862
             function which decides whether anything needs to go
3863
             into these sections.  */
3864
          s->flags |= SEC_EXCLUDE;
3865
          continue;
3866
        }
3867
 
3868
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
3869
        continue;
3870
 
3871
      /* Allocate memory for the section contents. We use bfd_zalloc here
3872
         in case unused entries are not reclaimed before the section's
3873
         contents are written out.  This should not happen, but this way
3874
         if it does, we will not write out garbage.  For reloc sections,
3875
         this will make entries have the type R_CRIS_NONE.  */
3876
      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3877
      if (s->contents == NULL)
3878
        return FALSE;
3879
    }
3880
 
3881
  if (elf_hash_table (info)->dynamic_sections_created)
3882
    {
3883
      /* Add some entries to the .dynamic section.  We fill in the
3884
         values later, in elf_cris_finish_dynamic_sections, but we
3885
         must add the entries now so that we get the correct size for
3886
         the .dynamic section.  The DT_DEBUG entry is filled in by the
3887
         dynamic linker and used by the debugger.  */
3888
#define add_dynamic_entry(TAG, VAL) \
3889
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3890
 
3891
      if (!info->shared)
3892
        {
3893
          if (!add_dynamic_entry (DT_DEBUG, 0))
3894
            return FALSE;
3895
        }
3896
 
3897
      if (plt)
3898
        {
3899
          if (!add_dynamic_entry (DT_PLTGOT, 0)
3900
              || !add_dynamic_entry (DT_PLTRELSZ, 0)
3901
              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3902
              || !add_dynamic_entry (DT_JMPREL, 0))
3903
            return FALSE;
3904
        }
3905
 
3906
      if (relocs)
3907
        {
3908
          if (!add_dynamic_entry (DT_RELA, 0)
3909
              || !add_dynamic_entry (DT_RELASZ, 0)
3910
              || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3911
            return FALSE;
3912
        }
3913
 
3914
      if ((info->flags & DF_TEXTREL) != 0)
3915
        {
3916
          if (!add_dynamic_entry (DT_TEXTREL, 0))
3917
            return FALSE;
3918
          info->flags |= DF_TEXTREL;
3919
        }
3920
    }
3921
#undef add_dynamic_entry
3922
 
3923
  return TRUE;
3924
}
3925
 
3926
/* This function is called via elf_cris_link_hash_traverse if we are
3927
   creating a shared object.  In the -Bsymbolic case, it discards the
3928
   space allocated to copy PC relative relocs against symbols which
3929
   are defined in regular objects.  For the normal non-symbolic case,
3930
   we also discard space for relocs that have become local due to
3931
   symbol visibility changes.  We allocated space for them in the
3932
   check_relocs routine, but we won't fill them in in the
3933
   relocate_section routine.  */
3934
 
3935
static bfd_boolean
3936
elf_cris_discard_excess_dso_dynamics (h, inf)
3937
     struct elf_cris_link_hash_entry *h;
3938
     PTR inf;
3939
{
3940
  struct elf_cris_pcrel_relocs_copied *s;
3941
  struct bfd_link_info *info = (struct bfd_link_info *) inf;
3942
 
3943
  if (h->root.root.type == bfd_link_hash_warning)
3944
    h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
3945
 
3946
  /* If a symbol has been forced local or we have found a regular
3947
     definition for the symbolic link case, then we won't be needing
3948
     any relocs.  */
3949
  if (h->root.def_regular
3950
      && (h->root.forced_local
3951
          || info->symbolic))
3952
    {
3953
      for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3954
        s->section->size -= s->count * sizeof (Elf32_External_Rela);
3955
 
3956
      return TRUE;
3957
    }
3958
 
3959
  /* If we have accounted for PC-relative relocs for read-only
3960
     sections, now is the time to warn for them.  We can't do it in
3961
     cris_elf_check_relocs, because we don't know the status of all
3962
     symbols at that time (and it's common to force symbols local
3963
     late).  */
3964
 
3965
  for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3966
    {
3967
      BFD_ASSERT ((s->section->flags & SEC_READONLY) != 0);
3968
 
3969
      /* FIXME: How do we make this optionally a warning only?  */
3970
      (*_bfd_error_handler)
3971
        (_("%B, section `%A', to symbol `%s':\n"
3972
           "  relocation %s should not be used"
3973
           " in a shared object; recompile with -fPIC"),
3974
         s->section->owner,
3975
         s->section,
3976
         h->root.root.root.string,
3977
         cris_elf_howto_table[s->r_type].name);
3978
 
3979
      info->flags |= DF_TEXTREL;
3980
    }
3981
 
3982
  return TRUE;
3983
}
3984
 
3985
/* This function is called via elf_cris_link_hash_traverse if we are *not*
3986
   creating a shared object.  We discard space for relocs for symbols put
3987
   in the .got, but which we found we do not have to resolve at run-time.  */
3988
 
3989
static bfd_boolean
3990
elf_cris_discard_excess_program_dynamics (h, inf)
3991
     struct elf_cris_link_hash_entry *h;
3992
     PTR inf;
3993
{
3994
  struct bfd_link_info *info = (struct bfd_link_info *) inf;
3995
 
3996
  if (h->root.root.type == bfd_link_hash_warning)
3997
    h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
3998
 
3999
  /* If we're not creating a shared library and have a symbol which is
4000
     referred to by .got references, but the symbol is defined locally,
4001
     (or rather, not defined by a DSO) then lose the reloc for the .got
4002
     (don't allocate room for it).  Likewise for relocs for something
4003
     for which we create a PLT.  */
4004
  if (!h->root.def_dynamic
4005
      || h->root.plt.refcount > 0)
4006
    {
4007
      if (h->reg_got_refcount > 0
4008
          /* The size of this section is only valid and in sync with the
4009
             various reference counts if we do dynamic; don't decrement it
4010
             otherwise.  */
4011
          && elf_hash_table (info)->dynamic_sections_created)
4012
        {
4013
          bfd *dynobj = elf_hash_table (info)->dynobj;
4014
          asection *srelgot;
4015
 
4016
          BFD_ASSERT (dynobj != NULL);
4017
 
4018
          srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4019
 
4020
          BFD_ASSERT (srelgot != NULL);
4021
 
4022
          srelgot->size -= sizeof (Elf32_External_Rela);
4023
        }
4024
 
4025
      /* If the locally-defined symbol isn't used by a DSO, then we don't
4026
         have to export it as a dynamic symbol.  This was already done for
4027
         functions; doing this for all symbols would presumably not
4028
         introduce new problems.  Of course we don't do this if we're
4029
         exporting all dynamic symbols.  */
4030
      if (! info->export_dynamic
4031
          && h->root.dynindx != -1
4032
          && !h->root.def_dynamic
4033
          && !h->root.ref_dynamic)
4034
        {
4035
          h->root.dynindx = -1;
4036
          _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4037
                                  h->root.dynstr_index);
4038
        }
4039
    }
4040
 
4041
  return TRUE;
4042
}
4043
 
4044
/* Reject a file depending on presence and expectation of prefixed
4045
   underscores on symbols.  */
4046
 
4047
static bfd_boolean
4048
cris_elf_object_p (abfd)
4049
     bfd *abfd;
4050
{
4051
  if (! cris_elf_set_mach_from_flags (abfd, elf_elfheader (abfd)->e_flags))
4052
    return FALSE;
4053
 
4054
  if ((elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE))
4055
    return (bfd_get_symbol_leading_char (abfd) == '_');
4056
  else
4057
    return (bfd_get_symbol_leading_char (abfd) == 0);
4058
}
4059
 
4060
/* Mark presence or absence of leading underscore.  Set machine type
4061
   flags from mach type.  */
4062
 
4063
static void
4064
cris_elf_final_write_processing (abfd, linker)
4065
     bfd *abfd;
4066
     bfd_boolean linker ATTRIBUTE_UNUSED;
4067
{
4068
  unsigned long e_flags = elf_elfheader (abfd)->e_flags;
4069
 
4070
  e_flags &= ~EF_CRIS_UNDERSCORE;
4071
  if (bfd_get_symbol_leading_char (abfd) == '_')
4072
    e_flags |= EF_CRIS_UNDERSCORE;
4073
 
4074
  switch (bfd_get_mach (abfd))
4075
    {
4076
    case bfd_mach_cris_v0_v10:
4077
      e_flags |= EF_CRIS_VARIANT_ANY_V0_V10;
4078
      break;
4079
 
4080
    case bfd_mach_cris_v10_v32:
4081
      e_flags |= EF_CRIS_VARIANT_COMMON_V10_V32;
4082
      break;
4083
 
4084
    case bfd_mach_cris_v32:
4085
      e_flags |= EF_CRIS_VARIANT_V32;
4086
      break;
4087
 
4088
    default:
4089
      _bfd_abort (__FILE__, __LINE__,
4090
                  _("Unexpected machine number"));
4091
    }
4092
 
4093
  elf_elfheader (abfd)->e_flags = e_flags;
4094
}
4095
 
4096
/* Set the mach type from e_flags value.  */
4097
 
4098
static bfd_boolean
4099
cris_elf_set_mach_from_flags (abfd, flags)
4100
     bfd *abfd;
4101
     unsigned long flags;
4102
{
4103
  switch (flags & EF_CRIS_VARIANT_MASK)
4104
    {
4105
    case EF_CRIS_VARIANT_ANY_V0_V10:
4106
      bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v0_v10);
4107
      break;
4108
 
4109
    case EF_CRIS_VARIANT_V32:
4110
      bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v32);
4111
      break;
4112
 
4113
    case EF_CRIS_VARIANT_COMMON_V10_V32:
4114
      bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v10_v32);
4115
      break;
4116
 
4117
    default:
4118
      /* Since we don't recognize them, we obviously can't support them
4119
         with this code; we'd have to require that all future handling
4120
         would be optional.  */
4121
      bfd_set_error (bfd_error_wrong_format);
4122
      return FALSE;
4123
    }
4124
 
4125
  return TRUE;
4126
}
4127
 
4128
/* Display the flags field.  */
4129
 
4130
static bfd_boolean
4131
cris_elf_print_private_bfd_data (abfd, ptr)
4132
     bfd *abfd;
4133
     PTR ptr;
4134
{
4135
  FILE *file = (FILE *) ptr;
4136
 
4137
  BFD_ASSERT (abfd != NULL && ptr != NULL);
4138
 
4139
  _bfd_elf_print_private_bfd_data (abfd, ptr);
4140
 
4141
  fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4142
 
4143
  if (elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE)
4144
    fprintf (file, _(" [symbols have a _ prefix]"));
4145
  if ((elf_elfheader (abfd)->e_flags & EF_CRIS_VARIANT_MASK)
4146
      == EF_CRIS_VARIANT_COMMON_V10_V32)
4147
    fprintf (file, _(" [v10 and v32]"));
4148
  if ((elf_elfheader (abfd)->e_flags & EF_CRIS_VARIANT_MASK)
4149
      == EF_CRIS_VARIANT_V32)
4150
    fprintf (file, _(" [v32]"));
4151
 
4152
  fputc ('\n', file);
4153
  return TRUE;
4154
}
4155
 
4156
/* Don't mix files with and without a leading underscore.  */
4157
 
4158
static bfd_boolean
4159
cris_elf_merge_private_bfd_data (ibfd, obfd)
4160
     bfd *ibfd;
4161
     bfd *obfd;
4162
{
4163
  int imach, omach;
4164
 
4165
  if (! _bfd_generic_verify_endian_match (ibfd, obfd))
4166
    return FALSE;
4167
 
4168
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4169
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4170
    return TRUE;
4171
 
4172
  imach = bfd_get_mach (ibfd);
4173
 
4174
  if (! elf_flags_init (obfd))
4175
    {
4176
      /* This happens when ld starts out with a 'blank' output file.  */
4177
      elf_flags_init (obfd) = TRUE;
4178
 
4179
      /* We ignore the linker-set mach, and instead set it according to
4180
         the first input file.  This would also happen if we could
4181
         somehow filter out the OUTPUT_ARCH () setting from elf.sc.
4182
         This allows us to keep the same linker config across
4183
         cris(v0..v10) and crisv32.  The drawback is that we can't force
4184
         the output type, which might be a sane thing to do for a
4185
         v10+v32 compatibility object.  */
4186
      if (! bfd_set_arch_mach (obfd, bfd_arch_cris, imach))
4187
        return FALSE;
4188
    }
4189
 
4190
  if (bfd_get_symbol_leading_char (ibfd)
4191
      != bfd_get_symbol_leading_char (obfd))
4192
    {
4193
      (*_bfd_error_handler)
4194
        (bfd_get_symbol_leading_char (ibfd) == '_'
4195
         ? _("%B: uses _-prefixed symbols, but writing file with non-prefixed symbols")
4196
         : _("%B: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
4197
         ibfd);
4198
      bfd_set_error (bfd_error_bad_value);
4199
      return FALSE;
4200
    }
4201
 
4202
  omach = bfd_get_mach (obfd);
4203
 
4204
  if (imach != omach)
4205
    {
4206
      /* We can get an incompatible combination only if either is
4207
         bfd_mach_cris_v32, and the other one isn't compatible.  */
4208
      if ((imach == bfd_mach_cris_v32
4209
           && omach != bfd_mach_cris_v10_v32)
4210
          || (omach == bfd_mach_cris_v32
4211
              && imach != bfd_mach_cris_v10_v32))
4212
        {
4213
          (*_bfd_error_handler)
4214
            ((imach == bfd_mach_cris_v32)
4215
             ? _("%B contains CRIS v32 code, incompatible"
4216
                 " with previous objects")
4217
             : _("%B contains non-CRIS-v32 code, incompatible"
4218
                 " with previous objects"),
4219
             ibfd);
4220
          bfd_set_error (bfd_error_bad_value);
4221
          return FALSE;
4222
        }
4223
 
4224
      /* We don't have to check the case where the input is compatible
4225
         with v10 and v32, because the output is already known to be set
4226
         to the other (compatible) mach.  */
4227
      if (omach == bfd_mach_cris_v10_v32
4228
          && ! bfd_set_arch_mach (obfd, bfd_arch_cris, imach))
4229
        return FALSE;
4230
    }
4231
 
4232
  return TRUE;
4233
}
4234
 
4235
/* Do side-effects of e_flags copying to obfd.  */
4236
 
4237
static bfd_boolean
4238
cris_elf_copy_private_bfd_data (ibfd, obfd)
4239
     bfd *ibfd;
4240
     bfd *obfd;
4241
{
4242
  /* Call the base function.  */
4243
  if (!_bfd_elf_copy_private_bfd_data (ibfd, obfd))
4244
    return FALSE;
4245
 
4246
  /* If output is big-endian for some obscure reason, stop here.  */
4247
  if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE)
4248
    return FALSE;
4249
 
4250
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4251
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4252
    return TRUE;
4253
 
4254
  /* Do what we really came here for.  */
4255
  return bfd_set_arch_mach (obfd, bfd_arch_cris, bfd_get_mach (ibfd));
4256
}
4257
 
4258
static enum elf_reloc_type_class
4259
elf_cris_reloc_type_class (rela)
4260
     const Elf_Internal_Rela *rela;
4261
{
4262
  enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rela->r_info);
4263
  switch (r_type)
4264
    {
4265
    case R_CRIS_RELATIVE:
4266
      return reloc_class_relative;
4267
    case R_CRIS_JUMP_SLOT:
4268
      return reloc_class_plt;
4269
    case R_CRIS_COPY:
4270
      return reloc_class_copy;
4271
    default:
4272
      return reloc_class_normal;
4273
    }
4274
}
4275
 
4276
/* The elf_backend_got_elt_size worker.  For one symbol, we can have up to
4277
   two GOT entries from three types with two different sizes.  We handle
4278
   it as a single entry, so we can use the regular offset-calculation
4279
   machinery.  */
4280
 
4281
static bfd_vma
4282
elf_cris_got_elt_size (bfd *abfd ATTRIBUTE_UNUSED,
4283
                       struct bfd_link_info *info ATTRIBUTE_UNUSED,
4284
                       struct elf_link_hash_entry *hr,
4285
                       bfd *ibfd,
4286
                       unsigned long symndx)
4287
{
4288
  struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) hr;
4289
  bfd_vma eltsiz = 0;
4290
 
4291
  /* We may have one regular GOT entry or up to two TLS GOT
4292
     entries.  */
4293
  if (h == NULL)
4294
    {
4295
      Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4296
      bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (ibfd);
4297
 
4298
      BFD_ASSERT (local_got_refcounts != NULL);
4299
 
4300
      if (local_got_refcounts[LGOT_REG_NDX (symndx)] > 0)
4301
        {
4302
          /* We can't have a variable referred to both as a regular
4303
             variable and through TLS relocs.  */
4304
          BFD_ASSERT (local_got_refcounts[LGOT_DTP_NDX (symndx)] == 0
4305
                      && local_got_refcounts[LGOT_TPREL_NDX (symndx)] == 0);
4306
          return 4;
4307
        }
4308
 
4309
      if (local_got_refcounts[LGOT_DTP_NDX (symndx)] > 0)
4310
        eltsiz += 8;
4311
 
4312
      if (local_got_refcounts[LGOT_TPREL_NDX (symndx)] > 0)
4313
        eltsiz += 4;
4314
    }
4315
  else
4316
    {
4317
      struct elf_cris_link_hash_entry *hh = elf_cris_hash_entry (h);
4318
      if (hh->reg_got_refcount > 0)
4319
        {
4320
          /* The actual error-on-input is emitted elsewhere.  */
4321
          BFD_ASSERT (hh->dtp_refcount == 0 && hh->tprel_refcount == 0);
4322
          return 4;
4323
        }
4324
 
4325
      if (hh->dtp_refcount > 0)
4326
        eltsiz += 8;
4327
 
4328
      if (hh->tprel_refcount > 0)
4329
        eltsiz += 4;
4330
    }
4331
 
4332
  /* We're only called when h->got.refcount is non-zero, so we must
4333
     have a non-zero size.  */
4334
  BFD_ASSERT (eltsiz != 0);
4335
  return eltsiz;
4336
}
4337
 
4338
#define ELF_ARCH                bfd_arch_cris
4339
#define ELF_MACHINE_CODE        EM_CRIS
4340
#define ELF_MAXPAGESIZE         0x2000
4341
 
4342
#define TARGET_LITTLE_SYM       bfd_elf32_cris_vec
4343
#define TARGET_LITTLE_NAME      "elf32-cris"
4344
#define elf_symbol_leading_char 0
4345
 
4346
#define elf_info_to_howto_rel                   NULL
4347
#define elf_info_to_howto                       cris_info_to_howto_rela
4348
#define elf_backend_relocate_section            cris_elf_relocate_section
4349
#define elf_backend_gc_mark_hook                cris_elf_gc_mark_hook
4350
#define elf_backend_gc_sweep_hook               cris_elf_gc_sweep_hook
4351
#define elf_backend_plt_sym_val                 cris_elf_plt_sym_val
4352
#define elf_backend_check_relocs                cris_elf_check_relocs
4353
#define elf_backend_grok_prstatus               cris_elf_grok_prstatus
4354
#define elf_backend_grok_psinfo                 cris_elf_grok_psinfo
4355
 
4356
#define elf_backend_can_gc_sections             1
4357
#define elf_backend_can_refcount                1
4358
 
4359
#define elf_backend_object_p                    cris_elf_object_p
4360
#define elf_backend_final_write_processing \
4361
        cris_elf_final_write_processing
4362
#define bfd_elf32_bfd_print_private_bfd_data \
4363
        cris_elf_print_private_bfd_data
4364
#define bfd_elf32_bfd_merge_private_bfd_data \
4365
        cris_elf_merge_private_bfd_data
4366
#define bfd_elf32_bfd_copy_private_bfd_data \
4367
        cris_elf_copy_private_bfd_data
4368
 
4369
#define bfd_elf32_bfd_reloc_type_lookup         cris_reloc_type_lookup
4370
#define bfd_elf32_bfd_reloc_name_lookup cris_reloc_name_lookup
4371
 
4372
#define bfd_elf32_bfd_link_hash_table_create \
4373
        elf_cris_link_hash_table_create
4374
#define elf_backend_adjust_dynamic_symbol \
4375
        elf_cris_adjust_dynamic_symbol
4376
#define elf_backend_copy_indirect_symbol \
4377
        elf_cris_copy_indirect_symbol
4378
#define elf_backend_size_dynamic_sections \
4379
        elf_cris_size_dynamic_sections
4380
#define elf_backend_init_index_section          _bfd_elf_init_1_index_section
4381
#define elf_backend_finish_dynamic_symbol \
4382
        elf_cris_finish_dynamic_symbol
4383
#define elf_backend_finish_dynamic_sections \
4384
        elf_cris_finish_dynamic_sections
4385
#define elf_backend_create_dynamic_sections \
4386
        _bfd_elf_create_dynamic_sections
4387
#define bfd_elf32_bfd_final_link \
4388
        bfd_elf_gc_common_final_link
4389
#define elf_backend_hide_symbol                 elf_cris_hide_symbol
4390
#define elf_backend_reloc_type_class            elf_cris_reloc_type_class
4391
 
4392
#define elf_backend_want_got_plt        1
4393
#define elf_backend_plt_readonly        1
4394
#define elf_backend_want_plt_sym        0
4395
#define elf_backend_got_header_size     12
4396
#define elf_backend_got_elt_size elf_cris_got_elt_size
4397
 
4398
/* Later, we my want to optimize RELA entries into REL entries for dynamic
4399
   linking and libraries (if it's a win of any significance).  Until then,
4400
   take the easy route.  */
4401
#define elf_backend_may_use_rel_p 0
4402
#define elf_backend_may_use_rela_p 1
4403
#define elf_backend_rela_normal         1
4404
 
4405
#include "elf32-target.h"
4406
 
4407
#undef TARGET_LITTLE_SYM
4408
#undef TARGET_LITTLE_NAME
4409
#undef elf_symbol_leading_char
4410
 
4411
#define TARGET_LITTLE_SYM bfd_elf32_us_cris_vec
4412
#define TARGET_LITTLE_NAME "elf32-us-cris"
4413
#define elf_symbol_leading_char '_'
4414
#undef elf32_bed
4415
#define elf32_bed elf32_us_cris_bed
4416
 
4417
#include "elf32-target.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.