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

Subversion Repositories openrisc

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* FRV-specific support for 32-bit ELF.
2
   Copyright 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3
   Free Software Foundation, Inc.
4
 
5
   This file is part of BFD, the Binary File Descriptor library.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
 
22
#include "sysdep.h"
23
#include "bfd.h"
24
#include "libbfd.h"
25
#include "elf-bfd.h"
26
#include "elf/frv.h"
27
#include "dwarf2.h"
28
#include "hashtab.h"
29
 
30
/* Forward declarations.  */
31
static bfd_reloc_status_type elf32_frv_relocate_lo16
32
  PARAMS ((bfd *,  Elf_Internal_Rela *, bfd_byte *, bfd_vma));
33
static bfd_reloc_status_type elf32_frv_relocate_hi16
34
  PARAMS ((bfd *,  Elf_Internal_Rela *, bfd_byte *, bfd_vma));
35
static bfd_reloc_status_type elf32_frv_relocate_label24
36
  PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
37
static bfd_reloc_status_type elf32_frv_relocate_gprel12
38
  PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
39
           bfd_byte *, bfd_vma));
40
static bfd_reloc_status_type elf32_frv_relocate_gprelu12
41
  PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
42
           bfd_byte *, bfd_vma));
43
static bfd_reloc_status_type elf32_frv_relocate_gprello
44
  PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
45
           bfd_byte *, bfd_vma));
46
static bfd_reloc_status_type elf32_frv_relocate_gprelhi
47
  PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
48
           bfd_byte *, bfd_vma));
49
static reloc_howto_type *frv_reloc_type_lookup
50
  PARAMS ((bfd *, bfd_reloc_code_real_type));
51
static void frv_info_to_howto_rela
52
  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
53
static bfd_boolean elf32_frv_relocate_section
54
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
55
           Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
56
static bfd_boolean elf32_frv_add_symbol_hook
57
  PARAMS (( bfd *, struct bfd_link_info *, Elf_Internal_Sym *,
58
            const char **, flagword *, asection **, bfd_vma *));
59
static bfd_reloc_status_type frv_final_link_relocate
60
  PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
61
           Elf_Internal_Rela *, bfd_vma));
62
static bfd_boolean elf32_frv_check_relocs
63
  PARAMS ((bfd *, struct bfd_link_info *, asection *,
64
           const Elf_Internal_Rela *));
65
static int elf32_frv_machine
66
  PARAMS ((bfd *));
67
static bfd_boolean elf32_frv_object_p
68
  PARAMS ((bfd *));
69
static bfd_boolean frv_elf_set_private_flags
70
  PARAMS ((bfd *, flagword));
71
static bfd_boolean frv_elf_copy_private_bfd_data
72
  PARAMS ((bfd *, bfd *));
73
static bfd_boolean frv_elf_merge_private_bfd_data
74
  PARAMS ((bfd *, bfd *));
75
static bfd_boolean frv_elf_print_private_bfd_data
76
  PARAMS ((bfd *, PTR));
77
static bfd_boolean elf32_frv_grok_prstatus (bfd * abfd,
78
                                            Elf_Internal_Note * note);
79
static bfd_boolean elf32_frv_grok_psinfo (bfd * abfd,
80
                                          Elf_Internal_Note * note);
81
 
82
static reloc_howto_type elf32_frv_howto_table [] =
83
{
84
  /* This reloc does nothing.  */
85
  HOWTO (R_FRV_NONE,            /* type */
86
         0,                      /* rightshift */
87
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
88
         32,                    /* bitsize */
89
         FALSE,                 /* pc_relative */
90
         0,                      /* bitpos */
91
         complain_overflow_bitfield, /* complain_on_overflow */
92
         bfd_elf_generic_reloc, /* special_function */
93
         "R_FRV_NONE",          /* name */
94
         FALSE,                 /* partial_inplace */
95
         0,                      /* src_mask */
96
         0,                      /* dst_mask */
97
         FALSE),                /* pcrel_offset */
98
 
99
  /* A 32 bit absolute relocation.  */
100
  HOWTO (R_FRV_32,              /* type */
101
         0,                      /* rightshift */
102
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
103
         32,                    /* bitsize */
104
         FALSE,                 /* pc_relative */
105
         0,                      /* bitpos */
106
         complain_overflow_bitfield, /* complain_on_overflow */
107
         bfd_elf_generic_reloc, /* special_function */
108
         "R_FRV_32",            /* name */
109
         FALSE,                 /* partial_inplace */
110
         0xffffffff,            /* src_mask */
111
         0xffffffff,            /* dst_mask */
112
         FALSE),                /* pcrel_offset */
113
 
114
  /* A 16 bit pc-relative relocation.  */
115
  HOWTO (R_FRV_LABEL16,         /* type */
116
         2,                     /* rightshift */
117
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
118
         16,                    /* bitsize */
119
         TRUE,                  /* pc_relative */
120
         0,                      /* bitpos */
121
         complain_overflow_signed, /* complain_on_overflow */
122
         bfd_elf_generic_reloc, /* special_function */
123
         "R_FRV_LABEL16",       /* name */
124
         FALSE,                 /* partial_inplace */
125
         0xffff,                /* src_mask */
126
         0xffff,                /* dst_mask */
127
         TRUE),                 /* pcrel_offset */
128
 
129
  /* A 24-bit pc-relative relocation.  */
130
  HOWTO (R_FRV_LABEL24,         /* type */
131
         2,                     /* rightshift */
132
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
133
         26,                    /* bitsize */
134
         TRUE,                  /* pc_relative */
135
         0,                      /* bitpos */
136
         complain_overflow_bitfield, /* complain_on_overflow */
137
         bfd_elf_generic_reloc, /* special_function */
138
         "R_FRV_LABEL24",       /* name */
139
         FALSE,                 /* partial_inplace */
140
         0x7e03ffff,            /* src_mask */
141
         0x7e03ffff,            /* dst_mask */
142
         TRUE),                 /* pcrel_offset */
143
 
144
  HOWTO (R_FRV_LO16,            /* type */
145
         0,                      /* rightshift */
146
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
147
         16,                    /* bitsize */
148
         FALSE,                 /* pc_relative */
149
         0,                      /* bitpos */
150
         complain_overflow_dont, /* complain_on_overflow */
151
         bfd_elf_generic_reloc, /* special_function */
152
         "R_FRV_LO16",          /* name */
153
         FALSE,                 /* partial_inplace */
154
         0xffff,                /* src_mask */
155
         0xffff,                /* dst_mask */
156
         FALSE),                /* pcrel_offset */
157
 
158
  HOWTO (R_FRV_HI16,            /* type */
159
         0,                      /* rightshift */
160
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
161
         16,                    /* bitsize */
162
         FALSE,                 /* pc_relative */
163
         0,                      /* bitpos */
164
         complain_overflow_dont, /* complain_on_overflow */
165
         bfd_elf_generic_reloc, /* special_function */
166
         "R_FRV_HI16",          /* name */
167
         FALSE,                 /* partial_inplace */
168
         0xffff,                /* src_mask */
169
         0xffff,                /* dst_mask */
170
         FALSE),                /* pcrel_offset */
171
 
172
  HOWTO (R_FRV_GPREL12,         /* type */
173
         0,                      /* rightshift */
174
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
175
         12,                    /* bitsize */
176
         FALSE,                 /* pc_relative */
177
         0,                      /* bitpos */
178
         complain_overflow_dont, /* complain_on_overflow */
179
         bfd_elf_generic_reloc, /* special_function */
180
         "R_FRV_GPREL12",       /* name */
181
         FALSE,                 /* partial_inplace */
182
         0xfff,                 /* src_mask */
183
         0xfff,                 /* dst_mask */
184
         FALSE),                /* pcrel_offset */
185
 
186
  HOWTO (R_FRV_GPRELU12,        /* type */
187
         0,                      /* rightshift */
188
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
189
         12,                    /* bitsize */
190
         FALSE,                 /* pc_relative */
191
         0,                      /* bitpos */
192
         complain_overflow_dont, /* complain_on_overflow */
193
         bfd_elf_generic_reloc, /* special_function */
194
         "R_FRV_GPRELU12",      /* name */
195
         FALSE,                 /* partial_inplace */
196
         0xfff,                 /* src_mask */
197
         0x3f03f,               /* dst_mask */
198
         FALSE),                /* pcrel_offset */
199
 
200
  HOWTO (R_FRV_GPREL32,         /* type */
201
         0,                      /* rightshift */
202
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
203
         32,                    /* bitsize */
204
         FALSE,                 /* pc_relative */
205
         0,                      /* bitpos */
206
         complain_overflow_dont, /* complain_on_overflow */
207
         bfd_elf_generic_reloc, /* special_function */
208
         "R_FRV_GPREL32",       /* name */
209
         FALSE,                 /* partial_inplace */
210
         0xffffffff,            /* src_mask */
211
         0xffffffff,            /* dst_mask */
212
         FALSE),                /* pcrel_offset */
213
 
214
  HOWTO (R_FRV_GPRELHI,         /* type */
215
         0,                      /* rightshift */
216
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
217
         16,                    /* bitsize */
218
         FALSE,                 /* pc_relative */
219
         0,                      /* bitpos */
220
         complain_overflow_dont, /* complain_on_overflow */
221
         bfd_elf_generic_reloc, /* special_function */
222
         "R_FRV_GPRELHI",       /* name */
223
         FALSE,                 /* partial_inplace */
224
         0xffff,                /* src_mask */
225
         0xffff,                /* dst_mask */
226
         FALSE),                /* pcrel_offset */
227
 
228
  HOWTO (R_FRV_GPRELLO,         /* type */
229
         0,                      /* rightshift */
230
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
231
         16,                    /* bitsize */
232
         FALSE,                 /* pc_relative */
233
         0,                      /* bitpos */
234
         complain_overflow_dont, /* complain_on_overflow */
235
         bfd_elf_generic_reloc, /* special_function */
236
         "R_FRV_GPRELLO",       /* name */
237
         FALSE,                 /* partial_inplace */
238
         0xffff,                /* src_mask */
239
         0xffff,                /* dst_mask */
240
         FALSE),                /* pcrel_offset */
241
 
242
  /* A 12-bit signed operand with the GOT offset for the address of
243
     the symbol.  */
244
  HOWTO (R_FRV_GOT12,           /* type */
245
         0,                      /* rightshift */
246
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
247
         12,                    /* bitsize */
248
         FALSE,                 /* pc_relative */
249
         0,                      /* bitpos */
250
         complain_overflow_signed, /* complain_on_overflow */
251
         bfd_elf_generic_reloc, /* special_function */
252
         "R_FRV_GOT12",         /* name */
253
         FALSE,                 /* partial_inplace */
254
         0xfff,                 /* src_mask */
255
         0xfff,                 /* dst_mask */
256
         FALSE),                /* pcrel_offset */
257
 
258
  /* The upper 16 bits of the GOT offset for the address of the
259
     symbol.  */
260
  HOWTO (R_FRV_GOTHI,           /* type */
261
         0,                      /* rightshift */
262
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
263
         16,                    /* bitsize */
264
         FALSE,                 /* pc_relative */
265
         0,                      /* bitpos */
266
         complain_overflow_dont, /* complain_on_overflow */
267
         bfd_elf_generic_reloc, /* special_function */
268
         "R_FRV_GOTHI",         /* name */
269
         FALSE,                 /* partial_inplace */
270
         0xffff,                /* src_mask */
271
         0xffff,                /* dst_mask */
272
         FALSE),                /* pcrel_offset */
273
 
274
  /* The lower 16 bits of the GOT offset for the address of the
275
     symbol.  */
276
  HOWTO (R_FRV_GOTLO,           /* type */
277
         0,                      /* rightshift */
278
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
279
         16,                    /* bitsize */
280
         FALSE,                 /* pc_relative */
281
         0,                      /* bitpos */
282
         complain_overflow_dont, /* complain_on_overflow */
283
         bfd_elf_generic_reloc, /* special_function */
284
         "R_FRV_GOTLO",         /* name */
285
         FALSE,                 /* partial_inplace */
286
         0xffff,                /* src_mask */
287
         0xffff,                /* dst_mask */
288
         FALSE),                /* pcrel_offset */
289
 
290
  /* The 32-bit address of the canonical descriptor of a function.  */
291
  HOWTO (R_FRV_FUNCDESC,        /* type */
292
         0,                      /* rightshift */
293
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
294
         32,                    /* bitsize */
295
         FALSE,                 /* pc_relative */
296
         0,                      /* bitpos */
297
         complain_overflow_bitfield, /* complain_on_overflow */
298
         bfd_elf_generic_reloc, /* special_function */
299
         "R_FRV_FUNCDESC",      /* name */
300
         FALSE,                 /* partial_inplace */
301
         0xffffffff,            /* src_mask */
302
         0xffffffff,            /* dst_mask */
303
         FALSE),                /* pcrel_offset */
304
 
305
  /* A 12-bit signed operand with the GOT offset for the address of
306
     canonical descriptor of a function.  */
307
  HOWTO (R_FRV_FUNCDESC_GOT12,  /* type */
308
         0,                      /* rightshift */
309
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
310
         12,                    /* bitsize */
311
         FALSE,                 /* pc_relative */
312
         0,                      /* bitpos */
313
         complain_overflow_signed, /* complain_on_overflow */
314
         bfd_elf_generic_reloc, /* special_function */
315
         "R_FRV_FUNCDESC_GOT12", /* name */
316
         FALSE,                 /* partial_inplace */
317
         0xfff,                 /* src_mask */
318
         0xfff,                 /* dst_mask */
319
         FALSE),                /* pcrel_offset */
320
 
321
  /* The upper 16 bits of the GOT offset for the address of the
322
     canonical descriptor of a function.  */
323
  HOWTO (R_FRV_FUNCDESC_GOTHI,  /* type */
324
         0,                      /* rightshift */
325
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
326
         16,                    /* bitsize */
327
         FALSE,                 /* pc_relative */
328
         0,                      /* bitpos */
329
         complain_overflow_dont, /* complain_on_overflow */
330
         bfd_elf_generic_reloc, /* special_function */
331
         "R_FRV_FUNCDESC_GOTHI", /* name */
332
         FALSE,                 /* partial_inplace */
333
         0xffff,                /* src_mask */
334
         0xffff,                /* dst_mask */
335
         FALSE),                /* pcrel_offset */
336
 
337
  /* The lower 16 bits of the GOT offset for the address of the
338
     canonical descriptor of a function.  */
339
  HOWTO (R_FRV_FUNCDESC_GOTLO,  /* type */
340
         0,                      /* rightshift */
341
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
342
         16,                    /* bitsize */
343
         FALSE,                 /* pc_relative */
344
         0,                      /* bitpos */
345
         complain_overflow_dont, /* complain_on_overflow */
346
         bfd_elf_generic_reloc, /* special_function */
347
         "R_FRV_FUNCDESC_GOTLO", /* name */
348
         FALSE,                 /* partial_inplace */
349
         0xffff,                /* src_mask */
350
         0xffff,                /* dst_mask */
351
         FALSE),                /* pcrel_offset */
352
 
353
  /* The 64-bit descriptor of a function.  */
354
  HOWTO (R_FRV_FUNCDESC_VALUE,  /* type */
355
         0,                      /* rightshift */
356
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
357
         64,                    /* bitsize */
358
         FALSE,                 /* pc_relative */
359
         0,                      /* bitpos */
360
         complain_overflow_bitfield, /* complain_on_overflow */
361
         bfd_elf_generic_reloc, /* special_function */
362
         "R_FRV_FUNCDESC_VALUE", /* name */
363
         FALSE,                 /* partial_inplace */
364
         0xffffffff,            /* src_mask */
365
         0xffffffff,            /* dst_mask */
366
         FALSE),                /* pcrel_offset */
367
 
368
  /* A 12-bit signed operand with the GOT offset for the address of
369
     canonical descriptor of a function.  */
370
  HOWTO (R_FRV_FUNCDESC_GOTOFF12, /* type */
371
         0,                      /* rightshift */
372
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
373
         12,                    /* bitsize */
374
         FALSE,                 /* pc_relative */
375
         0,                      /* bitpos */
376
         complain_overflow_signed, /* complain_on_overflow */
377
         bfd_elf_generic_reloc, /* special_function */
378
         "R_FRV_FUNCDESC_GOTOFF12", /* name */
379
         FALSE,                 /* partial_inplace */
380
         0xfff,                 /* src_mask */
381
         0xfff,                 /* dst_mask */
382
         FALSE),                /* pcrel_offset */
383
 
384
  /* The upper 16 bits of the GOT offset for the address of the
385
     canonical descriptor of a function.  */
386
  HOWTO (R_FRV_FUNCDESC_GOTOFFHI, /* type */
387
         0,                      /* rightshift */
388
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
389
         16,                    /* bitsize */
390
         FALSE,                 /* pc_relative */
391
         0,                      /* bitpos */
392
         complain_overflow_dont, /* complain_on_overflow */
393
         bfd_elf_generic_reloc, /* special_function */
394
         "R_FRV_FUNCDESC_GOTOFFHI", /* name */
395
         FALSE,                 /* partial_inplace */
396
         0xffff,                /* src_mask */
397
         0xffff,                /* dst_mask */
398
         FALSE),                /* pcrel_offset */
399
 
400
  /* The lower 16 bits of the GOT offset for the address of the
401
     canonical descriptor of a function.  */
402
  HOWTO (R_FRV_FUNCDESC_GOTOFFLO, /* type */
403
         0,                      /* rightshift */
404
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
405
         16,                    /* bitsize */
406
         FALSE,                 /* pc_relative */
407
         0,                      /* bitpos */
408
         complain_overflow_dont, /* complain_on_overflow */
409
         bfd_elf_generic_reloc, /* special_function */
410
         "R_FRV_FUNCDESC_GOTOFFLO", /* name */
411
         FALSE,                 /* partial_inplace */
412
         0xffff,                /* src_mask */
413
         0xffff,                /* dst_mask */
414
         FALSE),                /* pcrel_offset */
415
 
416
  /* A 12-bit signed operand with the GOT offset for the address of
417
     the symbol.  */
418
  HOWTO (R_FRV_GOTOFF12,        /* type */
419
         0,                      /* rightshift */
420
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
421
         12,                    /* bitsize */
422
         FALSE,                 /* pc_relative */
423
         0,                      /* bitpos */
424
         complain_overflow_signed, /* complain_on_overflow */
425
         bfd_elf_generic_reloc, /* special_function */
426
         "R_FRV_GOTOFF12",      /* name */
427
         FALSE,                 /* partial_inplace */
428
         0xfff,                 /* src_mask */
429
         0xfff,                 /* dst_mask */
430
         FALSE),                /* pcrel_offset */
431
 
432
  /* The upper 16 bits of the GOT offset for the address of the
433
     symbol.  */
434
  HOWTO (R_FRV_GOTOFFHI,        /* type */
435
         0,                      /* rightshift */
436
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
437
         16,                    /* bitsize */
438
         FALSE,                 /* pc_relative */
439
         0,                      /* bitpos */
440
         complain_overflow_dont, /* complain_on_overflow */
441
         bfd_elf_generic_reloc, /* special_function */
442
         "R_FRV_GOTOFFHI",      /* name */
443
         FALSE,                 /* partial_inplace */
444
         0xffff,                /* src_mask */
445
         0xffff,                /* dst_mask */
446
         FALSE),                /* pcrel_offset */
447
 
448
  /* The lower 16 bits of the GOT offset for the address of the
449
     symbol.  */
450
  HOWTO (R_FRV_GOTOFFLO,        /* type */
451
         0,                      /* rightshift */
452
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
453
         16,                    /* bitsize */
454
         FALSE,                 /* pc_relative */
455
         0,                      /* bitpos */
456
         complain_overflow_dont, /* complain_on_overflow */
457
         bfd_elf_generic_reloc, /* special_function */
458
         "R_FRV_GOTOFFLO",      /* name */
459
         FALSE,                 /* partial_inplace */
460
         0xffff,                /* src_mask */
461
         0xffff,                /* dst_mask */
462
         FALSE),                /* pcrel_offset */
463
 
464
  /* A 24-bit pc-relative relocation referencing the TLS PLT entry for
465
     a thread-local symbol.  If the symbol number is 0, it refers to
466
     the module.  */
467
  HOWTO (R_FRV_GETTLSOFF,       /* type */
468
         2,                     /* rightshift */
469
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
470
         26,                    /* bitsize */
471
         TRUE,                  /* pc_relative */
472
         0,                      /* bitpos */
473
         complain_overflow_bitfield, /* complain_on_overflow */
474
         bfd_elf_generic_reloc, /* special_function */
475
         "R_FRV_GETTLSOFF",     /* name */
476
         FALSE,                 /* partial_inplace */
477
         0x7e03ffff,            /* src_mask */
478
         0x7e03ffff,            /* dst_mask */
479
         TRUE),                 /* pcrel_offset */
480
 
481
  /* A 64-bit TLS descriptor for a symbol.  This relocation is only
482
     valid as a REL, dynamic relocation.  */
483
  HOWTO (R_FRV_TLSDESC_VALUE,   /* type */
484
         0,                      /* rightshift */
485
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
486
         64,                    /* bitsize */
487
         FALSE,                 /* pc_relative */
488
         0,                      /* bitpos */
489
         complain_overflow_bitfield, /* complain_on_overflow */
490
         bfd_elf_generic_reloc, /* special_function */
491
         "R_FRV_TLSDESC_VALUE", /* name */
492
         FALSE,                 /* partial_inplace */
493
         0xffffffff,            /* src_mask */
494
         0xffffffff,            /* dst_mask */
495
         FALSE),                /* pcrel_offset */
496
 
497
  /* A 12-bit signed operand with the GOT offset for the TLS
498
     descriptor of the symbol.  */
499
  HOWTO (R_FRV_GOTTLSDESC12,    /* type */
500
         0,                      /* rightshift */
501
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
502
         12,                    /* bitsize */
503
         FALSE,                 /* pc_relative */
504
         0,                      /* bitpos */
505
         complain_overflow_signed, /* complain_on_overflow */
506
         bfd_elf_generic_reloc, /* special_function */
507
         "R_FRV_GOTTLSDESC12",  /* name */
508
         FALSE,                 /* partial_inplace */
509
         0xfff,                 /* src_mask */
510
         0xfff,                 /* dst_mask */
511
         FALSE),                /* pcrel_offset */
512
 
513
  /* The upper 16 bits of the GOT offset for the TLS descriptor of the
514
     symbol.  */
515
  HOWTO (R_FRV_GOTTLSDESCHI,    /* type */
516
         0,                      /* rightshift */
517
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
518
         16,                    /* bitsize */
519
         FALSE,                 /* pc_relative */
520
         0,                      /* bitpos */
521
         complain_overflow_dont, /* complain_on_overflow */
522
         bfd_elf_generic_reloc, /* special_function */
523
         "R_FRV_GOTTLSDESCHI",  /* name */
524
         FALSE,                 /* partial_inplace */
525
         0xffff,                /* src_mask */
526
         0xffff,                /* dst_mask */
527
         FALSE),                /* pcrel_offset */
528
 
529
  /* The lower 16 bits of the GOT offset for the TLS descriptor of the
530
     symbol.  */
531
  HOWTO (R_FRV_GOTTLSDESCLO,    /* type */
532
         0,                      /* rightshift */
533
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
534
         16,                    /* bitsize */
535
         FALSE,                 /* pc_relative */
536
         0,                      /* bitpos */
537
         complain_overflow_dont, /* complain_on_overflow */
538
         bfd_elf_generic_reloc, /* special_function */
539
         "R_FRV_GOTTLSDESCLO",  /* name */
540
         FALSE,                 /* partial_inplace */
541
         0xffff,                /* src_mask */
542
         0xffff,                /* dst_mask */
543
         FALSE),                /* pcrel_offset */
544
 
545
  /* A 12-bit signed operand with the offset from the module base
546
     address to the thread-local symbol address.  */
547
  HOWTO (R_FRV_TLSMOFF12,        /* type */
548
         0,                      /* rightshift */
549
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
550
         12,                    /* bitsize */
551
         FALSE,                 /* pc_relative */
552
         0,                      /* bitpos */
553
         complain_overflow_signed, /* complain_on_overflow */
554
         bfd_elf_generic_reloc, /* special_function */
555
         "R_FRV_TLSMOFF12",     /* name */
556
         FALSE,                 /* partial_inplace */
557
         0xfff,                 /* src_mask */
558
         0xfff,                 /* dst_mask */
559
         FALSE),                /* pcrel_offset */
560
 
561
  /* The upper 16 bits of the offset from the module base address to
562
     the thread-local symbol address.  */
563
  HOWTO (R_FRV_TLSMOFFHI,       /* type */
564
         0,                      /* rightshift */
565
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
566
         16,                    /* bitsize */
567
         FALSE,                 /* pc_relative */
568
         0,                      /* bitpos */
569
         complain_overflow_dont, /* complain_on_overflow */
570
         bfd_elf_generic_reloc, /* special_function */
571
         "R_FRV_TLSMOFFHI",     /* name */
572
         FALSE,                 /* partial_inplace */
573
         0xffff,                /* src_mask */
574
         0xffff,                /* dst_mask */
575
         FALSE),                /* pcrel_offset */
576
 
577
  /* The lower 16 bits of the offset from the module base address to
578
     the thread-local symbol address.  */
579
  HOWTO (R_FRV_TLSMOFFLO,       /* type */
580
         0,                      /* rightshift */
581
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
582
         16,                    /* bitsize */
583
         FALSE,                 /* pc_relative */
584
         0,                      /* bitpos */
585
         complain_overflow_dont, /* complain_on_overflow */
586
         bfd_elf_generic_reloc, /* special_function */
587
         "R_FRV_TLSMOFFLO",     /* name */
588
         FALSE,                 /* partial_inplace */
589
         0xffff,                /* src_mask */
590
         0xffff,                /* dst_mask */
591
         FALSE),                /* pcrel_offset */
592
 
593
  /* A 12-bit signed operand with the GOT offset for the TLSOFF entry
594
     for a symbol.  */
595
  HOWTO (R_FRV_GOTTLSOFF12,     /* type */
596
         0,                      /* rightshift */
597
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
598
         12,                    /* bitsize */
599
         FALSE,                 /* pc_relative */
600
         0,                      /* bitpos */
601
         complain_overflow_signed, /* complain_on_overflow */
602
         bfd_elf_generic_reloc, /* special_function */
603
         "R_FRV_GOTTLSOFF12",   /* name */
604
         FALSE,                 /* partial_inplace */
605
         0xfff,                 /* src_mask */
606
         0xfff,                 /* dst_mask */
607
         FALSE),                /* pcrel_offset */
608
 
609
  /* The upper 16 bits of the GOT offset for the TLSOFF entry for a
610
     symbol.  */
611
  HOWTO (R_FRV_GOTTLSOFFHI,     /* type */
612
         0,                      /* rightshift */
613
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
614
         16,                    /* bitsize */
615
         FALSE,                 /* pc_relative */
616
         0,                      /* bitpos */
617
         complain_overflow_dont, /* complain_on_overflow */
618
         bfd_elf_generic_reloc, /* special_function */
619
         "R_FRV_GOTTLSOFFHI",   /* name */
620
         FALSE,                 /* partial_inplace */
621
         0xffff,                /* src_mask */
622
         0xffff,                /* dst_mask */
623
         FALSE),                /* pcrel_offset */
624
 
625
  /* The lower 16 bits of the GOT offset for the TLSOFF entry for a
626
     symbol.  */
627
  HOWTO (R_FRV_GOTTLSOFFLO,     /* type */
628
         0,                      /* rightshift */
629
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
630
         16,                    /* bitsize */
631
         FALSE,                 /* pc_relative */
632
         0,                      /* bitpos */
633
         complain_overflow_dont, /* complain_on_overflow */
634
         bfd_elf_generic_reloc, /* special_function */
635
         "R_FRV_GOTTLSOFFLO",   /* name */
636
         FALSE,                 /* partial_inplace */
637
         0xffff,                /* src_mask */
638
         0xffff,                /* dst_mask */
639
         FALSE),                /* pcrel_offset */
640
 
641
  /* The 32-bit offset from the thread pointer (not the module base
642
     address) to a thread-local symbol.  */
643
  HOWTO (R_FRV_TLSOFF,          /* type */
644
         0,                      /* rightshift */
645
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
646
         32,                    /* bitsize */
647
         FALSE,                 /* pc_relative */
648
         0,                      /* bitpos */
649
         complain_overflow_dont, /* complain_on_overflow */
650
         bfd_elf_generic_reloc, /* special_function */
651
         "R_FRV_TLSOFF",        /* name */
652
         FALSE,                 /* partial_inplace */
653
         0xffffffff,            /* src_mask */
654
         0xffffffff,            /* dst_mask */
655
         FALSE),                /* pcrel_offset */
656
 
657
  /* An annotation for linker relaxation, that denotes the
658
     symbol+addend whose TLS descriptor is referenced by the sum of
659
     the two input registers of an ldd instruction.  */
660
  HOWTO (R_FRV_TLSDESC_RELAX,   /* type */
661
         0,                      /* rightshift */
662
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
663
         0,                      /* bitsize */
664
         FALSE,                 /* pc_relative */
665
         0,                      /* bitpos */
666
         complain_overflow_dont, /* complain_on_overflow */
667
         bfd_elf_generic_reloc, /* special_function */
668
         "R_FRV_TLSDESC_RELAX", /* name */
669
         FALSE,                 /* partial_inplace */
670
         0,                      /* src_mask */
671
         0,                      /* dst_mask */
672
         FALSE),                /* pcrel_offset */
673
 
674
  /* An annotation for linker relaxation, that denotes the
675
     symbol+addend whose TLS resolver entry point is given by the sum
676
     of the two register operands of an calll instruction.  */
677
  HOWTO (R_FRV_GETTLSOFF_RELAX, /* type */
678
         0,                      /* rightshift */
679
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
680
         0,                      /* bitsize */
681
         FALSE,                 /* pc_relative */
682
         0,                      /* bitpos */
683
         complain_overflow_dont, /* complain_on_overflow */
684
         bfd_elf_generic_reloc, /* special_function */
685
         "R_FRV_GETTLSOFF_RELAX", /* name */
686
         FALSE,                 /* partial_inplace */
687
         0,                      /* src_mask */
688
         0,                      /* dst_mask */
689
         FALSE),                /* pcrel_offset */
690
 
691
  /* An annotation for linker relaxation, that denotes the
692
     symbol+addend whose TLS offset GOT entry is given by the sum of
693
     the two input registers of an ld instruction.  */
694
  HOWTO (R_FRV_TLSOFF_RELAX,    /* type */
695
         0,                      /* rightshift */
696
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
697
         0,                      /* bitsize */
698
         FALSE,                 /* pc_relative */
699
         0,                      /* bitpos */
700
         complain_overflow_bitfield, /* complain_on_overflow */
701
         bfd_elf_generic_reloc, /* special_function */
702
         "R_FRV_TLSOFF_RELAX",  /* name */
703
         FALSE,                 /* partial_inplace */
704
         0,                      /* src_mask */
705
         0,                      /* dst_mask */
706
         FALSE),                /* pcrel_offset */
707
 
708
  /* A 32-bit offset from the module base address to
709
     the thread-local symbol address.  */
710
  HOWTO (R_FRV_TLSMOFF,         /* type */
711
         0,                      /* rightshift */
712
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
713
         32,                    /* bitsize */
714
         FALSE,                 /* pc_relative */
715
         0,                      /* bitpos */
716
         complain_overflow_dont, /* complain_on_overflow */
717
         bfd_elf_generic_reloc, /* special_function */
718
         "R_FRV_TLSMOFF",       /* name */
719
         FALSE,                 /* partial_inplace */
720
         0xffffffff,            /* src_mask */
721
         0xffffffff,            /* dst_mask */
722
         FALSE),                /* pcrel_offset */
723
};
724
 
725
/* GNU extension to record C++ vtable hierarchy.  */
726
static reloc_howto_type elf32_frv_vtinherit_howto =
727
  HOWTO (R_FRV_GNU_VTINHERIT,   /* type */
728
         0,                      /* rightshift */
729
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
730
         0,                      /* bitsize */
731
         FALSE,                 /* pc_relative */
732
         0,                      /* bitpos */
733
         complain_overflow_dont, /* complain_on_overflow */
734
         NULL,                  /* special_function */
735
         "R_FRV_GNU_VTINHERIT", /* name */
736
         FALSE,                 /* partial_inplace */
737
         0,                      /* src_mask */
738
         0,                      /* dst_mask */
739
         FALSE);                /* pcrel_offset */
740
 
741
  /* GNU extension to record C++ vtable member usage.  */
742
static reloc_howto_type elf32_frv_vtentry_howto =
743
  HOWTO (R_FRV_GNU_VTENTRY,     /* type */
744
         0,                      /* rightshift */
745
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
746
         0,                      /* bitsize */
747
         FALSE,                 /* pc_relative */
748
         0,                      /* bitpos */
749
         complain_overflow_dont, /* complain_on_overflow */
750
         _bfd_elf_rel_vtable_reloc_fn, /* special_function */
751
         "R_FRV_GNU_VTENTRY",   /* name */
752
         FALSE,                 /* partial_inplace */
753
         0,                      /* src_mask */
754
         0,                      /* dst_mask */
755
         FALSE);                /* pcrel_offset */
756
 
757
/* The following 3 relocations are REL.  The only difference to the
758
   entries in the table above are that partial_inplace is TRUE.  */
759
static reloc_howto_type elf32_frv_rel_32_howto =
760
  HOWTO (R_FRV_32,              /* type */
761
         0,                      /* rightshift */
762
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
763
         32,                    /* bitsize */
764
         FALSE,                 /* pc_relative */
765
         0,                      /* bitpos */
766
         complain_overflow_bitfield, /* complain_on_overflow */
767
         bfd_elf_generic_reloc, /* special_function */
768
         "R_FRV_32",            /* name */
769
         TRUE,                  /* partial_inplace */
770
         0xffffffff,            /* src_mask */
771
         0xffffffff,            /* dst_mask */
772
         FALSE);                /* pcrel_offset */
773
 
774
static reloc_howto_type elf32_frv_rel_funcdesc_howto =
775
  HOWTO (R_FRV_FUNCDESC,        /* type */
776
         0,                      /* rightshift */
777
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
778
         32,                    /* bitsize */
779
         FALSE,                 /* pc_relative */
780
         0,                      /* bitpos */
781
         complain_overflow_bitfield, /* complain_on_overflow */
782
         bfd_elf_generic_reloc, /* special_function */
783
         "R_FRV_FUNCDESC",      /* name */
784
         TRUE,                  /* partial_inplace */
785
         0xffffffff,            /* src_mask */
786
         0xffffffff,            /* dst_mask */
787
         FALSE);                /* pcrel_offset */
788
 
789
static reloc_howto_type elf32_frv_rel_funcdesc_value_howto =
790
  HOWTO (R_FRV_FUNCDESC_VALUE,  /* type */
791
         0,                      /* rightshift */
792
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
793
         64,                    /* bitsize */
794
         FALSE,                 /* pc_relative */
795
         0,                      /* bitpos */
796
         complain_overflow_bitfield, /* complain_on_overflow */
797
         bfd_elf_generic_reloc, /* special_function */
798
         "R_FRV_FUNCDESC_VALUE", /* name */
799
         TRUE,                  /* partial_inplace */
800
         0xffffffff,            /* src_mask */
801
         0xffffffff,            /* dst_mask */
802
         FALSE);                /* pcrel_offset */
803
 
804
static reloc_howto_type elf32_frv_rel_tlsdesc_value_howto =
805
  /* A 64-bit TLS descriptor for a symbol.  The first word resolves to
806
     an entry point, and the second resolves to a special argument.
807
     If the symbol turns out to be in static TLS, the entry point is a
808
     return instruction, and the special argument is the TLS offset
809
     for the symbol.  If it's in dynamic TLS, the entry point is a TLS
810
     offset resolver, and the special argument is a pointer to a data
811
     structure allocated by the dynamic loader, containing the GOT
812
     address for the offset resolver, the module id, the offset within
813
     the module, and anything else the TLS offset resolver might need
814
     to determine the TLS offset for the symbol in the running
815
     thread.  */
816
  HOWTO (R_FRV_TLSDESC_VALUE,   /* type */
817
         0,                      /* rightshift */
818
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
819
         64,                    /* bitsize */
820
         FALSE,                 /* pc_relative */
821
         0,                      /* bitpos */
822
         complain_overflow_bitfield, /* complain_on_overflow */
823
         bfd_elf_generic_reloc, /* special_function */
824
         "R_FRV_TLSDESC_VALUE", /* name */
825
         TRUE,                  /* partial_inplace */
826
         0xffffffff,            /* src_mask */
827
         0xffffffff,            /* dst_mask */
828
         FALSE);                /* pcrel_offset */
829
 
830
static reloc_howto_type elf32_frv_rel_tlsoff_howto =
831
  /* The 32-bit offset from the thread pointer (not the module base
832
     address) to a thread-local symbol.  */
833
  HOWTO (R_FRV_TLSOFF,          /* type */
834
         0,                      /* rightshift */
835
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
836
         32,                    /* bitsize */
837
         FALSE,                 /* pc_relative */
838
         0,                      /* bitpos */
839
         complain_overflow_bitfield, /* complain_on_overflow */
840
         bfd_elf_generic_reloc, /* special_function */
841
         "R_FRV_TLSOFF",        /* name */
842
         TRUE,                  /* partial_inplace */
843
         0xffffffff,            /* src_mask */
844
         0xffffffff,            /* dst_mask */
845
         FALSE);                /* pcrel_offset */
846
 
847
 
848
 
849
extern const bfd_target bfd_elf32_frvfdpic_vec;
850
#define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_frvfdpic_vec)
851
 
852
/* An extension of the elf hash table data structure, containing some
853
   additional FRV-specific data.  */
854
struct frvfdpic_elf_link_hash_table
855
{
856
  struct elf_link_hash_table elf;
857
 
858
  /* A pointer to the .got section.  */
859
  asection *sgot;
860
  /* A pointer to the .rel.got section.  */
861
  asection *sgotrel;
862
  /* A pointer to the .rofixup section.  */
863
  asection *sgotfixup;
864
  /* A pointer to the .plt section.  */
865
  asection *splt;
866
  /* A pointer to the .rel.plt section.  */
867
  asection *spltrel;
868
  /* GOT base offset.  */
869
  bfd_vma got0;
870
  /* Location of the first non-lazy PLT entry, i.e., the number of
871
     bytes taken by lazy PLT entries.  If locally-bound TLS
872
     descriptors require a ret instruction, it will be placed at this
873
     offset.  */
874
  bfd_vma plt0;
875
  /* A hash table holding information about which symbols were
876
     referenced with which PIC-related relocations.  */
877
  struct htab *relocs_info;
878
  /* Summary reloc information collected by
879
     _frvfdpic_count_got_plt_entries.  */
880
  struct _frvfdpic_dynamic_got_info *g;
881
};
882
 
883
/* Get the FRV ELF linker hash table from a link_info structure.  */
884
 
885
#define frvfdpic_hash_table(p) \
886
  (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
887
  == FRV_ELF_DATA ? ((struct frvfdpic_elf_link_hash_table *) ((p)->hash)) : NULL)
888
 
889
#define frvfdpic_got_section(info) \
890
  (frvfdpic_hash_table (info)->sgot)
891
#define frvfdpic_gotrel_section(info) \
892
  (frvfdpic_hash_table (info)->sgotrel)
893
#define frvfdpic_gotfixup_section(info) \
894
  (frvfdpic_hash_table (info)->sgotfixup)
895
#define frvfdpic_plt_section(info) \
896
  (frvfdpic_hash_table (info)->splt)
897
#define frvfdpic_pltrel_section(info) \
898
  (frvfdpic_hash_table (info)->spltrel)
899
#define frvfdpic_relocs_info(info) \
900
  (frvfdpic_hash_table (info)->relocs_info)
901
#define frvfdpic_got_initial_offset(info) \
902
  (frvfdpic_hash_table (info)->got0)
903
#define frvfdpic_plt_initial_offset(info) \
904
  (frvfdpic_hash_table (info)->plt0)
905
#define frvfdpic_dynamic_got_plt_info(info) \
906
  (frvfdpic_hash_table (info)->g)
907
 
908
/* Currently it's the same, but if some day we have a reason to change
909
   it, we'd better be using a different macro.
910
 
911
   FIXME: if there's any TLS PLT entry that uses local-exec or
912
   initial-exec models, we could use the ret at the end of any of them
913
   instead of adding one more.  */
914
#define frvfdpic_plt_tls_ret_offset(info) \
915
  (frvfdpic_plt_initial_offset (info))
916
 
917
/* The name of the dynamic interpreter.  This is put in the .interp
918
   section.  */
919
 
920
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
921
 
922
#define DEFAULT_STACK_SIZE 0x20000
923
 
924
/* This structure is used to collect the number of entries present in
925
   each addressable range of the got.  */
926
struct _frvfdpic_dynamic_got_info
927
{
928
  /* Several bits of information about the current link.  */
929
  struct bfd_link_info *info;
930
  /* Total GOT size needed for GOT entries within the 12-, 16- or 32-bit
931
     ranges.  */
932
  bfd_vma got12, gotlos, gothilo;
933
  /* Total GOT size needed for function descriptor entries within the 12-,
934
     16- or 32-bit ranges.  */
935
  bfd_vma fd12, fdlos, fdhilo;
936
  /* Total GOT size needed by function descriptor entries referenced
937
     in PLT entries, that would be profitable to place in offsets
938
     close to the PIC register.  */
939
  bfd_vma fdplt;
940
  /* Total PLT size needed by lazy PLT entries.  */
941
  bfd_vma lzplt;
942
  /* Total GOT size needed for TLS descriptor entries within the 12-,
943
     16- or 32-bit ranges.  */
944
  bfd_vma tlsd12, tlsdlos, tlsdhilo;
945
  /* Total GOT size needed by TLS descriptors referenced in PLT
946
     entries, that would be profitable to place in offers close to the
947
     PIC register.  */
948
  bfd_vma tlsdplt;
949
  /* Total PLT size needed by TLS lazy PLT entries.  */
950
  bfd_vma tlslzplt;
951
  /* Number of relocations carried over from input object files.  */
952
  unsigned long relocs;
953
  /* Number of fixups introduced by relocations in input object files.  */
954
  unsigned long fixups;
955
  /* The number of fixups that reference the ret instruction added to
956
     the PLT for locally-resolved TLS descriptors.  */
957
  unsigned long tls_ret_refs;
958
};
959
 
960
/* This structure is used to assign offsets to got entries, function
961
   descriptors, plt entries and lazy plt entries.  */
962
 
963
struct _frvfdpic_dynamic_got_plt_info
964
{
965
  /* Summary information collected with _frvfdpic_count_got_plt_entries.  */
966
  struct _frvfdpic_dynamic_got_info g;
967
 
968
  /* For each addressable range, we record a MAX (positive) and MIN
969
     (negative) value.  CUR is used to assign got entries, and it's
970
     incremented from an initial positive value to MAX, then from MIN
971
     to FDCUR (unless FDCUR wraps around first).  FDCUR is used to
972
     assign function descriptors, and it's decreased from an initial
973
     non-positive value to MIN, then from MAX down to CUR (unless CUR
974
     wraps around first).  All of MIN, MAX, CUR and FDCUR always point
975
     to even words.  ODD, if non-zero, indicates an odd word to be
976
     used for the next got entry, otherwise CUR is used and
977
     incremented by a pair of words, wrapping around when it reaches
978
     MAX.  FDCUR is decremented (and wrapped) before the next function
979
     descriptor is chosen.  FDPLT indicates the number of remaining
980
     slots that can be used for function descriptors used only by PLT
981
     entries.
982
 
983
     TMAX, TMIN and TCUR are used to assign TLS descriptors.  TCUR
984
     starts as MAX, and grows up to TMAX, then wraps around to TMIN
985
     and grows up to MIN.  TLSDPLT indicates the number of remaining
986
     slots that can be used for TLS descriptors used only by TLS PLT
987
     entries.  */
988
  struct _frvfdpic_dynamic_got_alloc_data
989
  {
990
    bfd_signed_vma max, cur, odd, fdcur, min;
991
    bfd_signed_vma tmax, tcur, tmin;
992
    bfd_vma fdplt, tlsdplt;
993
  } got12, gotlos, gothilo;
994
};
995
 
996
/* Create an FRV ELF linker hash table.  */
997
 
998
static struct bfd_link_hash_table *
999
frvfdpic_elf_link_hash_table_create (bfd *abfd)
1000
{
1001
  struct frvfdpic_elf_link_hash_table *ret;
1002
  bfd_size_type amt = sizeof (struct frvfdpic_elf_link_hash_table);
1003
 
1004
  ret = bfd_zalloc (abfd, amt);
1005
  if (ret == NULL)
1006
    return NULL;
1007
 
1008
  if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1009
                                      _bfd_elf_link_hash_newfunc,
1010
                                      sizeof (struct elf_link_hash_entry),
1011
                                      FRV_ELF_DATA))
1012
    {
1013
      free (ret);
1014
      return NULL;
1015
    }
1016
 
1017
  return &ret->elf.root;
1018
}
1019
 
1020
/* Decide whether a reference to a symbol can be resolved locally or
1021
   not.  If the symbol is protected, we want the local address, but
1022
   its function descriptor must be assigned by the dynamic linker.  */
1023
#define FRVFDPIC_SYM_LOCAL(INFO, H) \
1024
  (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
1025
   || ! elf_hash_table (INFO)->dynamic_sections_created)
1026
#define FRVFDPIC_FUNCDESC_LOCAL(INFO, H) \
1027
  ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
1028
 
1029
/* This structure collects information on what kind of GOT, PLT or
1030
   function descriptors are required by relocations that reference a
1031
   certain symbol.  */
1032
struct frvfdpic_relocs_info
1033
{
1034
  /* The index of the symbol, as stored in the relocation r_info, if
1035
     we have a local symbol; -1 otherwise.  */
1036
  long symndx;
1037
  union
1038
  {
1039
    /* The input bfd in which the symbol is defined, if it's a local
1040
       symbol.  */
1041
    bfd *abfd;
1042
    /* If symndx == -1, the hash table entry corresponding to a global
1043
       symbol (even if it turns out to bind locally, in which case it
1044
       should ideally be replaced with section's symndx + addend).  */
1045
    struct elf_link_hash_entry *h;
1046
  } d;
1047
  /* The addend of the relocation that references the symbol.  */
1048
  bfd_vma addend;
1049
 
1050
  /* The fields above are used to identify an entry.  The fields below
1051
     contain information on how an entry is used and, later on, which
1052
     locations it was assigned.  */
1053
  /* The following 3 fields record whether the symbol+addend above was
1054
     ever referenced with a GOT relocation.  The 12 suffix indicates a
1055
     GOT12 relocation; los is used for GOTLO relocations that are not
1056
     matched by a GOTHI relocation; hilo is used for GOTLO/GOTHI
1057
     pairs.  */
1058
  unsigned got12:1;
1059
  unsigned gotlos:1;
1060
  unsigned gothilo:1;
1061
  /* Whether a FUNCDESC relocation references symbol+addend.  */
1062
  unsigned fd:1;
1063
  /* Whether a FUNCDESC_GOT relocation references symbol+addend.  */
1064
  unsigned fdgot12:1;
1065
  unsigned fdgotlos:1;
1066
  unsigned fdgothilo:1;
1067
  /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend.  */
1068
  unsigned fdgoff12:1;
1069
  unsigned fdgofflos:1;
1070
  unsigned fdgoffhilo:1;
1071
  /* Whether a GETTLSOFF relocation references symbol+addend.  */
1072
  unsigned tlsplt:1;
1073
  /* FIXME: we should probably add tlspltdesc, tlspltoff and
1074
     tlspltimm, to tell what kind of TLS PLT entry we're generating.
1075
     We might instead just pre-compute flags telling whether the
1076
     object is suitable for local exec, initial exec or general
1077
     dynamic addressing, and use that all over the place.  We could
1078
     also try to do a better job of merging TLSOFF and TLSDESC entries
1079
     in main executables, but perhaps we can get rid of TLSDESC
1080
     entirely in them instead.  */
1081
  /* Whether a GOTTLSDESC relocation references symbol+addend.  */
1082
  unsigned tlsdesc12:1;
1083
  unsigned tlsdesclos:1;
1084
  unsigned tlsdeschilo:1;
1085
  /* Whether a GOTTLSOFF relocation references symbol+addend.  */
1086
  unsigned tlsoff12:1;
1087
  unsigned tlsofflos:1;
1088
  unsigned tlsoffhilo:1;
1089
  /* Whether symbol+addend is referenced with GOTOFF12, GOTOFFLO or
1090
     GOTOFFHI relocations.  The addend doesn't really matter, since we
1091
     envision that this will only be used to check whether the symbol
1092
     is mapped to the same segment as the got.  */
1093
  unsigned gotoff:1;
1094
  /* Whether symbol+addend is referenced by a LABEL24 relocation.  */
1095
  unsigned call:1;
1096
  /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
1097
     relocation.  */
1098
  unsigned sym:1;
1099
  /* Whether we need a PLT entry for a symbol.  Should be implied by
1100
     something like:
1101
     (call && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h))  */
1102
  unsigned plt:1;
1103
  /* Whether a function descriptor should be created in this link unit
1104
     for symbol+addend.  Should be implied by something like:
1105
     (plt || fdgotoff12 || fdgotofflos || fdgotofflohi
1106
      || ((fd || fdgot12 || fdgotlos || fdgothilo)
1107
          && (symndx != -1 || FRVFDPIC_FUNCDESC_LOCAL (info, d.h))))  */
1108
  unsigned privfd:1;
1109
  /* Whether a lazy PLT entry is needed for this symbol+addend.
1110
     Should be implied by something like:
1111
     (privfd && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h)
1112
      && ! (info->flags & DF_BIND_NOW))  */
1113
  unsigned lazyplt:1;
1114
  /* Whether we've already emitted GOT relocations and PLT entries as
1115
     needed for this symbol.  */
1116
  unsigned done:1;
1117
 
1118
  /* The number of R_FRV_32, R_FRV_FUNCDESC, R_FRV_FUNCDESC_VALUE and
1119
     R_FRV_TLSDESC_VALUE, R_FRV_TLSOFF relocations referencing
1120
     symbol+addend.  */
1121
  unsigned relocs32, relocsfd, relocsfdv, relocstlsd, relocstlsoff;
1122
 
1123
  /* The number of .rofixups entries and dynamic relocations allocated
1124
     for this symbol, minus any that might have already been used.  */
1125
  unsigned fixups, dynrelocs;
1126
 
1127
  /* The offsets of the GOT entries assigned to symbol+addend, to the
1128
     function descriptor's address, and to a function descriptor,
1129
     respectively.  Should be zero if unassigned.  The offsets are
1130
     counted from the value that will be assigned to the PIC register,
1131
     not from the beginning of the .got section.  */
1132
  bfd_signed_vma got_entry, fdgot_entry, fd_entry;
1133
  /* The offsets of the PLT entries assigned to symbol+addend,
1134
     non-lazy and lazy, respectively.  If unassigned, should be
1135
     (bfd_vma)-1.  */
1136
  bfd_vma plt_entry, lzplt_entry;
1137
  /* The offsets of the GOT entries for TLS offset and TLS descriptor.  */
1138
  bfd_signed_vma tlsoff_entry, tlsdesc_entry;
1139
  /* The offset of the TLS offset PLT entry.  */
1140
  bfd_vma tlsplt_entry;
1141
};
1142
 
1143
/* Compute a hash with the key fields of an frvfdpic_relocs_info entry.  */
1144
static hashval_t
1145
frvfdpic_relocs_info_hash (const void *entry_)
1146
{
1147
  const struct frvfdpic_relocs_info *entry = entry_;
1148
 
1149
  return (entry->symndx == -1
1150
          ? (long) entry->d.h->root.root.hash
1151
          : entry->symndx + (long) entry->d.abfd->id * 257) + entry->addend;
1152
}
1153
 
1154
/* Test whether the key fields of two frvfdpic_relocs_info entries are
1155
   identical.  */
1156
static int
1157
frvfdpic_relocs_info_eq (const void *entry1, const void *entry2)
1158
{
1159
  const struct frvfdpic_relocs_info *e1 = entry1;
1160
  const struct frvfdpic_relocs_info *e2 = entry2;
1161
 
1162
  return e1->symndx == e2->symndx && e1->addend == e2->addend
1163
    && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd);
1164
}
1165
 
1166
/* Find or create an entry in a hash table HT that matches the key
1167
   fields of the given ENTRY.  If it's not found, memory for a new
1168
   entry is allocated in ABFD's obstack.  */
1169
static struct frvfdpic_relocs_info *
1170
frvfdpic_relocs_info_find (struct htab *ht,
1171
                           bfd *abfd,
1172
                           const struct frvfdpic_relocs_info *entry,
1173
                           enum insert_option insert)
1174
{
1175
  struct frvfdpic_relocs_info **loc =
1176
    (struct frvfdpic_relocs_info **) htab_find_slot (ht, entry, insert);
1177
 
1178
  if (! loc)
1179
    return NULL;
1180
 
1181
  if (*loc)
1182
    return *loc;
1183
 
1184
  *loc = bfd_zalloc (abfd, sizeof (**loc));
1185
 
1186
  if (! *loc)
1187
    return *loc;
1188
 
1189
  (*loc)->symndx = entry->symndx;
1190
  (*loc)->d = entry->d;
1191
  (*loc)->addend = entry->addend;
1192
  (*loc)->plt_entry = (bfd_vma)-1;
1193
  (*loc)->lzplt_entry = (bfd_vma)-1;
1194
  (*loc)->tlsplt_entry = (bfd_vma)-1;
1195
 
1196
  return *loc;
1197
}
1198
 
1199
/* Obtain the address of the entry in HT associated with H's symbol +
1200
   addend, creating a new entry if none existed.  ABFD is only used
1201
   for memory allocation purposes.  */
1202
inline static struct frvfdpic_relocs_info *
1203
frvfdpic_relocs_info_for_global (struct htab *ht,
1204
                                 bfd *abfd,
1205
                                 struct elf_link_hash_entry *h,
1206
                                 bfd_vma addend,
1207
                                 enum insert_option insert)
1208
{
1209
  struct frvfdpic_relocs_info entry;
1210
 
1211
  entry.symndx = -1;
1212
  entry.d.h = h;
1213
  entry.addend = addend;
1214
 
1215
  return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
1216
}
1217
 
1218
/* Obtain the address of the entry in HT associated with the SYMNDXth
1219
   local symbol of the input bfd ABFD, plus the addend, creating a new
1220
   entry if none existed.  */
1221
inline static struct frvfdpic_relocs_info *
1222
frvfdpic_relocs_info_for_local (struct htab *ht,
1223
                                bfd *abfd,
1224
                                long symndx,
1225
                                bfd_vma addend,
1226
                                enum insert_option insert)
1227
{
1228
  struct frvfdpic_relocs_info entry;
1229
 
1230
  entry.symndx = symndx;
1231
  entry.d.abfd = abfd;
1232
  entry.addend = addend;
1233
 
1234
  return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
1235
}
1236
 
1237
/* Merge fields set by check_relocs() of two entries that end up being
1238
   mapped to the same (presumably global) symbol.  */
1239
 
1240
inline static void
1241
frvfdpic_pic_merge_early_relocs_info (struct frvfdpic_relocs_info *e2,
1242
                                      struct frvfdpic_relocs_info const *e1)
1243
{
1244
  e2->got12 |= e1->got12;
1245
  e2->gotlos |= e1->gotlos;
1246
  e2->gothilo |= e1->gothilo;
1247
  e2->fd |= e1->fd;
1248
  e2->fdgot12 |= e1->fdgot12;
1249
  e2->fdgotlos |= e1->fdgotlos;
1250
  e2->fdgothilo |= e1->fdgothilo;
1251
  e2->fdgoff12 |= e1->fdgoff12;
1252
  e2->fdgofflos |= e1->fdgofflos;
1253
  e2->fdgoffhilo |= e1->fdgoffhilo;
1254
  e2->tlsplt |= e1->tlsplt;
1255
  e2->tlsdesc12 |= e1->tlsdesc12;
1256
  e2->tlsdesclos |= e1->tlsdesclos;
1257
  e2->tlsdeschilo |= e1->tlsdeschilo;
1258
  e2->tlsoff12 |= e1->tlsoff12;
1259
  e2->tlsofflos |= e1->tlsofflos;
1260
  e2->tlsoffhilo |= e1->tlsoffhilo;
1261
  e2->gotoff |= e1->gotoff;
1262
  e2->call |= e1->call;
1263
  e2->sym |= e1->sym;
1264
}
1265
 
1266
/* Every block of 65535 lazy PLT entries shares a single call to the
1267
   resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
1268
   32767, counting from 0).  All other lazy PLT entries branch to it
1269
   in a single instruction.  */
1270
 
1271
#define FRVFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) 8 * 65535 + 4)
1272
#define FRVFDPIC_LZPLT_RESOLV_LOC (8 * 32767)
1273
 
1274
/* Add a dynamic relocation to the SRELOC section.  */
1275
 
1276
inline static bfd_vma
1277
_frvfdpic_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
1278
                         int reloc_type, long dynindx, bfd_vma addend,
1279
                         struct frvfdpic_relocs_info *entry)
1280
{
1281
  Elf_Internal_Rela outrel;
1282
  bfd_vma reloc_offset;
1283
 
1284
  outrel.r_offset = offset;
1285
  outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
1286
  outrel.r_addend = addend;
1287
 
1288
  reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel);
1289
  BFD_ASSERT (reloc_offset < sreloc->size);
1290
  bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1291
                            sreloc->contents + reloc_offset);
1292
  sreloc->reloc_count++;
1293
 
1294
  /* If the entry's index is zero, this relocation was probably to a
1295
     linkonce section that got discarded.  We reserved a dynamic
1296
     relocation, but it was for another entry than the one we got at
1297
     the time of emitting the relocation.  Unfortunately there's no
1298
     simple way for us to catch this situation, since the relocation
1299
     is cleared right before calling relocate_section, at which point
1300
     we no longer know what the relocation used to point to.  */
1301
  if (entry->symndx)
1302
    {
1303
      BFD_ASSERT (entry->dynrelocs > 0);
1304
      entry->dynrelocs--;
1305
    }
1306
 
1307
  return reloc_offset;
1308
}
1309
 
1310
/* Add a fixup to the ROFIXUP section.  */
1311
 
1312
static bfd_vma
1313
_frvfdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset,
1314
                       struct frvfdpic_relocs_info *entry)
1315
{
1316
  bfd_vma fixup_offset;
1317
 
1318
  if (rofixup->flags & SEC_EXCLUDE)
1319
    return -1;
1320
 
1321
  fixup_offset = rofixup->reloc_count * 4;
1322
  if (rofixup->contents)
1323
    {
1324
      BFD_ASSERT (fixup_offset < rofixup->size);
1325
      bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset);
1326
    }
1327
  rofixup->reloc_count++;
1328
 
1329
  if (entry && entry->symndx)
1330
    {
1331
      /* See discussion about symndx == 0 in _frvfdpic_add_dyn_reloc
1332
         above.  */
1333
      BFD_ASSERT (entry->fixups > 0);
1334
      entry->fixups--;
1335
    }
1336
 
1337
  return fixup_offset;
1338
}
1339
 
1340
/* Find the segment number in which OSEC, and output section, is
1341
   located.  */
1342
 
1343
static unsigned
1344
_frvfdpic_osec_to_segment (bfd *output_bfd, asection *osec)
1345
{
1346
  Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section (output_bfd, osec);
1347
 
1348
  return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1;
1349
}
1350
 
1351
inline static bfd_boolean
1352
_frvfdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
1353
{
1354
  unsigned seg = _frvfdpic_osec_to_segment (output_bfd, osec);
1355
 
1356
  return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
1357
}
1358
 
1359
#define FRVFDPIC_TLS_BIAS (2048 - 16)
1360
 
1361
/* Return the base VMA address which should be subtracted from real addresses
1362
   when resolving TLSMOFF relocation.
1363
   This is PT_TLS segment p_vaddr, plus the 2048-16 bias.  */
1364
 
1365
static bfd_vma
1366
tls_biased_base (struct bfd_link_info *info)
1367
{
1368
  /* If tls_sec is NULL, we should have signalled an error already.  */
1369
  if (elf_hash_table (info)->tls_sec == NULL)
1370
    return FRVFDPIC_TLS_BIAS;
1371
  return elf_hash_table (info)->tls_sec->vma + FRVFDPIC_TLS_BIAS;
1372
}
1373
 
1374
/* Generate relocations for GOT entries, function descriptors, and
1375
   code for PLT and lazy PLT entries.  */
1376
 
1377
inline static bfd_boolean
1378
_frvfdpic_emit_got_relocs_plt_entries (struct frvfdpic_relocs_info *entry,
1379
                                       bfd *output_bfd,
1380
                                       struct bfd_link_info *info,
1381
                                       asection *sec,
1382
                                       Elf_Internal_Sym *sym,
1383
                                       bfd_vma addend)
1384
 
1385
{
1386
  bfd_vma fd_lazy_rel_offset = (bfd_vma)-1;
1387
  int dynindx = -1;
1388
 
1389
  if (entry->done)
1390
    return TRUE;
1391
  entry->done = 1;
1392
 
1393
  if (entry->got_entry || entry->fdgot_entry || entry->fd_entry
1394
      || entry->tlsoff_entry || entry->tlsdesc_entry)
1395
    {
1396
      /* If the symbol is dynamic, consider it for dynamic
1397
         relocations, otherwise decay to section + offset.  */
1398
      if (entry->symndx == -1 && entry->d.h->dynindx != -1)
1399
        dynindx = entry->d.h->dynindx;
1400
      else
1401
        {
1402
          if (sec
1403
              && sec->output_section
1404
              && ! bfd_is_abs_section (sec->output_section)
1405
              && ! bfd_is_und_section (sec->output_section))
1406
            dynindx = elf_section_data (sec->output_section)->dynindx;
1407
          else
1408
            dynindx = 0;
1409
        }
1410
    }
1411
 
1412
  /* Generate relocation for GOT entry pointing to the symbol.  */
1413
  if (entry->got_entry)
1414
    {
1415
      int idx = dynindx;
1416
      bfd_vma ad = addend;
1417
 
1418
      /* If the symbol is dynamic but binds locally, use
1419
         section+offset.  */
1420
      if (sec && (entry->symndx != -1
1421
                  || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1422
        {
1423
          if (entry->symndx == -1)
1424
            ad += entry->d.h->root.u.def.value;
1425
          else
1426
            ad += sym->st_value;
1427
          ad += sec->output_offset;
1428
          if (sec->output_section && elf_section_data (sec->output_section))
1429
            idx = elf_section_data (sec->output_section)->dynindx;
1430
          else
1431
            idx = 0;
1432
        }
1433
 
1434
      /* If we're linking an executable at a fixed address, we can
1435
         omit the dynamic relocation as long as the symbol is local to
1436
         this module.  */
1437
      if (info->executable && !info->pie
1438
          && (entry->symndx != -1
1439
              || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1440
        {
1441
          if (sec)
1442
            ad += sec->output_section->vma;
1443
          if (entry->symndx != -1
1444
              || entry->d.h->root.type != bfd_link_hash_undefweak)
1445
            _frvfdpic_add_rofixup (output_bfd,
1446
                                   frvfdpic_gotfixup_section (info),
1447
                                   frvfdpic_got_section (info)->output_section
1448
                                   ->vma
1449
                                   + frvfdpic_got_section (info)->output_offset
1450
                                   + frvfdpic_got_initial_offset (info)
1451
                                   + entry->got_entry, entry);
1452
        }
1453
      else
1454
        _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1455
                                 _bfd_elf_section_offset
1456
                                 (output_bfd, info,
1457
                                  frvfdpic_got_section (info),
1458
                                  frvfdpic_got_initial_offset (info)
1459
                                  + entry->got_entry)
1460
                                 + frvfdpic_got_section (info)
1461
                                 ->output_section->vma
1462
                                 + frvfdpic_got_section (info)->output_offset,
1463
                                 R_FRV_32, idx, ad, entry);
1464
 
1465
      bfd_put_32 (output_bfd, ad,
1466
                  frvfdpic_got_section (info)->contents
1467
                  + frvfdpic_got_initial_offset (info)
1468
                  + entry->got_entry);
1469
    }
1470
 
1471
  /* Generate relocation for GOT entry pointing to a canonical
1472
     function descriptor.  */
1473
  if (entry->fdgot_entry)
1474
    {
1475
      int reloc, idx;
1476
      bfd_vma ad = 0;
1477
 
1478
      if (! (entry->symndx == -1
1479
             && entry->d.h->root.type == bfd_link_hash_undefweak
1480
             && FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1481
        {
1482
          /* If the symbol is dynamic and there may be dynamic symbol
1483
             resolution because we are, or are linked with, a shared
1484
             library, emit a FUNCDESC relocation such that the dynamic
1485
             linker will allocate the function descriptor.  If the
1486
             symbol needs a non-local function descriptor but binds
1487
             locally (e.g., its visibility is protected, emit a
1488
             dynamic relocation decayed to section+offset.  */
1489
          if (entry->symndx == -1
1490
              && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)
1491
              && FRVFDPIC_SYM_LOCAL (info, entry->d.h)
1492
              && !(info->executable && !info->pie))
1493
            {
1494
              reloc = R_FRV_FUNCDESC;
1495
              idx = elf_section_data (entry->d.h->root.u.def.section
1496
                                      ->output_section)->dynindx;
1497
              ad = entry->d.h->root.u.def.section->output_offset
1498
                + entry->d.h->root.u.def.value;
1499
            }
1500
          else if (entry->symndx == -1
1501
                   && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h))
1502
            {
1503
              reloc = R_FRV_FUNCDESC;
1504
              idx = dynindx;
1505
              ad = addend;
1506
              if (ad)
1507
                {
1508
                  (*info->callbacks->reloc_dangerous)
1509
                    (info, _("relocation requires zero addend"),
1510
                     elf_hash_table (info)->dynobj,
1511
                     frvfdpic_got_section (info),
1512
                     entry->fdgot_entry);
1513
                  return FALSE;
1514
                }
1515
            }
1516
          else
1517
            {
1518
              /* Otherwise, we know we have a private function descriptor,
1519
                 so reference it directly.  */
1520
              if (elf_hash_table (info)->dynamic_sections_created)
1521
                BFD_ASSERT (entry->privfd);
1522
              reloc = R_FRV_32;
1523
              idx = elf_section_data (frvfdpic_got_section (info)
1524
                                      ->output_section)->dynindx;
1525
              ad = frvfdpic_got_section (info)->output_offset
1526
                + frvfdpic_got_initial_offset (info) + entry->fd_entry;
1527
            }
1528
 
1529
          /* If there is room for dynamic symbol resolution, emit the
1530
             dynamic relocation.  However, if we're linking an
1531
             executable at a fixed location, we won't have emitted a
1532
             dynamic symbol entry for the got section, so idx will be
1533
             zero, which means we can and should compute the address
1534
             of the private descriptor ourselves.  */
1535
          if (info->executable && !info->pie
1536
              && (entry->symndx != -1
1537
                  || FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)))
1538
            {
1539
              ad += frvfdpic_got_section (info)->output_section->vma;
1540
              _frvfdpic_add_rofixup (output_bfd,
1541
                                     frvfdpic_gotfixup_section (info),
1542
                                     frvfdpic_got_section (info)
1543
                                     ->output_section->vma
1544
                                     + frvfdpic_got_section (info)
1545
                                     ->output_offset
1546
                                     + frvfdpic_got_initial_offset (info)
1547
                                     + entry->fdgot_entry, entry);
1548
            }
1549
          else
1550
            _frvfdpic_add_dyn_reloc (output_bfd,
1551
                                     frvfdpic_gotrel_section (info),
1552
                                     _bfd_elf_section_offset
1553
                                     (output_bfd, info,
1554
                                      frvfdpic_got_section (info),
1555
                                      frvfdpic_got_initial_offset (info)
1556
                                      + entry->fdgot_entry)
1557
                                     + frvfdpic_got_section (info)
1558
                                     ->output_section->vma
1559
                                     + frvfdpic_got_section (info)
1560
                                     ->output_offset,
1561
                                     reloc, idx, ad, entry);
1562
        }
1563
 
1564
      bfd_put_32 (output_bfd, ad,
1565
                  frvfdpic_got_section (info)->contents
1566
                  + frvfdpic_got_initial_offset (info)
1567
                  + entry->fdgot_entry);
1568
    }
1569
 
1570
  /* Generate relocation to fill in a private function descriptor in
1571
     the GOT.  */
1572
  if (entry->fd_entry)
1573
    {
1574
      int idx = dynindx;
1575
      bfd_vma ad = addend;
1576
      bfd_vma ofst;
1577
      long lowword, highword;
1578
 
1579
      /* If the symbol is dynamic but binds locally, use
1580
         section+offset.  */
1581
      if (sec && (entry->symndx != -1
1582
                  || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1583
        {
1584
          if (entry->symndx == -1)
1585
            ad += entry->d.h->root.u.def.value;
1586
          else
1587
            ad += sym->st_value;
1588
          ad += sec->output_offset;
1589
          if (sec->output_section && elf_section_data (sec->output_section))
1590
            idx = elf_section_data (sec->output_section)->dynindx;
1591
          else
1592
            idx = 0;
1593
        }
1594
 
1595
      /* If we're linking an executable at a fixed address, we can
1596
         omit the dynamic relocation as long as the symbol is local to
1597
         this module.  */
1598
      if (info->executable && !info->pie
1599
          && (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1600
        {
1601
          if (sec)
1602
            ad += sec->output_section->vma;
1603
          ofst = 0;
1604
          if (entry->symndx != -1
1605
              || entry->d.h->root.type != bfd_link_hash_undefweak)
1606
            {
1607
              _frvfdpic_add_rofixup (output_bfd,
1608
                                     frvfdpic_gotfixup_section (info),
1609
                                     frvfdpic_got_section (info)
1610
                                     ->output_section->vma
1611
                                     + frvfdpic_got_section (info)
1612
                                     ->output_offset
1613
                                     + frvfdpic_got_initial_offset (info)
1614
                                     + entry->fd_entry, entry);
1615
              _frvfdpic_add_rofixup (output_bfd,
1616
                                     frvfdpic_gotfixup_section (info),
1617
                                     frvfdpic_got_section (info)
1618
                                     ->output_section->vma
1619
                                     + frvfdpic_got_section (info)
1620
                                     ->output_offset
1621
                                     + frvfdpic_got_initial_offset (info)
1622
                                     + entry->fd_entry + 4, entry);
1623
            }
1624
        }
1625
      else
1626
        {
1627
          ofst =
1628
            _frvfdpic_add_dyn_reloc (output_bfd,
1629
                                     entry->lazyplt
1630
                                     ? frvfdpic_pltrel_section (info)
1631
                                     : frvfdpic_gotrel_section (info),
1632
                                     _bfd_elf_section_offset
1633
                                     (output_bfd, info,
1634
                                      frvfdpic_got_section (info),
1635
                                      frvfdpic_got_initial_offset (info)
1636
                                      + entry->fd_entry)
1637
                                     + frvfdpic_got_section (info)
1638
                                     ->output_section->vma
1639
                                     + frvfdpic_got_section (info)
1640
                                     ->output_offset,
1641
                                     R_FRV_FUNCDESC_VALUE, idx, ad, entry);
1642
        }
1643
 
1644
      /* If we've omitted the dynamic relocation, just emit the fixed
1645
         addresses of the symbol and of the local GOT base offset.  */
1646
      if (info->executable && !info->pie && sec && sec->output_section)
1647
        {
1648
          lowword = ad;
1649
          highword = frvfdpic_got_section (info)->output_section->vma
1650
            + frvfdpic_got_section (info)->output_offset
1651
            + frvfdpic_got_initial_offset (info);
1652
        }
1653
      else if (entry->lazyplt)
1654
        {
1655
          if (ad)
1656
            {
1657
              (*info->callbacks->reloc_dangerous)
1658
                (info, _("relocation requires zero addend"),
1659
                 elf_hash_table (info)->dynobj,
1660
                 frvfdpic_got_section (info),
1661
                 entry->fd_entry);
1662
              return FALSE;
1663
            }
1664
 
1665
          fd_lazy_rel_offset = ofst;
1666
 
1667
          /* A function descriptor used for lazy or local resolving is
1668
             initialized such that its high word contains the output
1669
             section index in which the PLT entries are located, and
1670
             the low word contains the address of the lazy PLT entry
1671
             entry point, that must be within the memory region
1672
             assigned to that section.  */
1673
          lowword = entry->lzplt_entry + 4
1674
            + frvfdpic_plt_section (info)->output_offset
1675
            + frvfdpic_plt_section (info)->output_section->vma;
1676
          highword = _frvfdpic_osec_to_segment
1677
            (output_bfd, frvfdpic_plt_section (info)->output_section);
1678
        }
1679
      else
1680
        {
1681
          /* A function descriptor for a local function gets the index
1682
             of the section.  For a non-local function, it's
1683
             disregarded.  */
1684
          lowword = ad;
1685
          if (sec == NULL
1686
              || (entry->symndx == -1 && entry->d.h->dynindx != -1
1687
                  && entry->d.h->dynindx == idx))
1688
            highword = 0;
1689
          else
1690
            highword = _frvfdpic_osec_to_segment
1691
              (output_bfd, sec->output_section);
1692
        }
1693
 
1694
      bfd_put_32 (output_bfd, lowword,
1695
                  frvfdpic_got_section (info)->contents
1696
                  + frvfdpic_got_initial_offset (info)
1697
                  + entry->fd_entry);
1698
      bfd_put_32 (output_bfd, highword,
1699
                  frvfdpic_got_section (info)->contents
1700
                  + frvfdpic_got_initial_offset (info)
1701
                  + entry->fd_entry + 4);
1702
    }
1703
 
1704
  /* Generate code for the PLT entry.  */
1705
  if (entry->plt_entry != (bfd_vma) -1)
1706
    {
1707
      bfd_byte *plt_code = frvfdpic_plt_section (info)->contents
1708
        + entry->plt_entry;
1709
 
1710
      BFD_ASSERT (entry->fd_entry);
1711
 
1712
      /* Figure out what kind of PLT entry we need, depending on the
1713
         location of the function descriptor within the GOT.  */
1714
      if (entry->fd_entry >= -(1 << (12 - 1))
1715
          && entry->fd_entry < (1 << (12 - 1)))
1716
        {
1717
          /* lddi @(gr15, fd_entry), gr14 */
1718
          bfd_put_32 (output_bfd,
1719
                      0x9cccf000 | (entry->fd_entry & ((1 << 12) - 1)),
1720
                      plt_code);
1721
          plt_code += 4;
1722
        }
1723
      else
1724
        {
1725
          if (entry->fd_entry >= -(1 << (16 - 1))
1726
              && entry->fd_entry < (1 << (16 - 1)))
1727
            {
1728
              /* setlos lo(fd_entry), gr14 */
1729
              bfd_put_32 (output_bfd,
1730
                          0x9cfc0000
1731
                          | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1732
                          plt_code);
1733
              plt_code += 4;
1734
            }
1735
          else
1736
            {
1737
              /* sethi.p hi(fd_entry), gr14
1738
                 setlo lo(fd_entry), gr14 */
1739
              bfd_put_32 (output_bfd,
1740
                          0x1cf80000
1741
                          | ((entry->fd_entry >> 16)
1742
                             & (((bfd_vma)1 << 16) - 1)),
1743
                          plt_code);
1744
              plt_code += 4;
1745
              bfd_put_32 (output_bfd,
1746
                          0x9cf40000
1747
                          | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1748
                          plt_code);
1749
              plt_code += 4;
1750
            }
1751
          /* ldd @(gr14,gr15),gr14 */
1752
          bfd_put_32 (output_bfd, 0x9c08e14f, plt_code);
1753
          plt_code += 4;
1754
        }
1755
      /* jmpl @(gr14,gr0) */
1756
      bfd_put_32 (output_bfd, 0x8030e000, plt_code);
1757
    }
1758
 
1759
  /* Generate code for the lazy PLT entry.  */
1760
  if (entry->lzplt_entry != (bfd_vma) -1)
1761
    {
1762
      bfd_byte *lzplt_code = frvfdpic_plt_section (info)->contents
1763
        + entry->lzplt_entry;
1764
      bfd_vma resolverStub_addr;
1765
 
1766
      bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code);
1767
      lzplt_code += 4;
1768
 
1769
      resolverStub_addr = entry->lzplt_entry / FRVFDPIC_LZPLT_BLOCK_SIZE
1770
        * FRVFDPIC_LZPLT_BLOCK_SIZE + FRVFDPIC_LZPLT_RESOLV_LOC;
1771
      if (resolverStub_addr >= frvfdpic_plt_initial_offset (info))
1772
        resolverStub_addr = frvfdpic_plt_initial_offset (info) - 12;
1773
 
1774
      if (entry->lzplt_entry == resolverStub_addr)
1775
        {
1776
          /* This is a lazy PLT entry that includes a resolver call.  */
1777
          /* ldd @(gr15,gr0), gr4
1778
             jmpl @(gr4,gr0)  */
1779
          bfd_put_32 (output_bfd, 0x8808f140, lzplt_code);
1780
          bfd_put_32 (output_bfd, 0x80304000, lzplt_code + 4);
1781
        }
1782
      else
1783
        {
1784
          /* bra  resolverStub */
1785
          bfd_put_32 (output_bfd,
1786
                      0xc01a0000
1787
                      | (((resolverStub_addr - entry->lzplt_entry)
1788
                          / 4) & (((bfd_vma)1 << 16) - 1)),
1789
                      lzplt_code);
1790
        }
1791
    }
1792
 
1793
  /* Generate relocation for GOT entry holding the TLS offset.  */
1794
  if (entry->tlsoff_entry)
1795
    {
1796
      int idx = dynindx;
1797
      bfd_vma ad = addend;
1798
 
1799
      if (entry->symndx != -1
1800
          || FRVFDPIC_SYM_LOCAL (info, entry->d.h))
1801
        {
1802
          /* If the symbol is dynamic but binds locally, use
1803
             section+offset.  */
1804
          if (sec)
1805
            {
1806
              if (entry->symndx == -1)
1807
                ad += entry->d.h->root.u.def.value;
1808
              else
1809
                ad += sym->st_value;
1810
              ad += sec->output_offset;
1811
              if (sec->output_section
1812
                  && elf_section_data (sec->output_section))
1813
                idx = elf_section_data (sec->output_section)->dynindx;
1814
              else
1815
                idx = 0;
1816
            }
1817
        }
1818
 
1819
      /* *ABS*+addend is special for TLS relocations, use only the
1820
         addend.  */
1821
      if (info->executable
1822
          && idx == 0
1823
          && (bfd_is_abs_section (sec)
1824
              || bfd_is_und_section (sec)))
1825
        ;
1826
      /* If we're linking an executable, we can entirely omit the
1827
         dynamic relocation if the symbol is local to this module.  */
1828
      else if (info->executable
1829
               && (entry->symndx != -1
1830
                   || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1831
        {
1832
          if (sec)
1833
            ad += sec->output_section->vma - tls_biased_base (info);
1834
        }
1835
      else
1836
        {
1837
          if (idx == 0
1838
              && (bfd_is_abs_section (sec)
1839
                  || bfd_is_und_section (sec)))
1840
            {
1841
              if (! elf_hash_table (info)->tls_sec)
1842
                {
1843
                  (*info->callbacks->undefined_symbol)
1844
                    (info, "TLS section", elf_hash_table (info)->dynobj,
1845
                     frvfdpic_got_section (info), entry->tlsoff_entry, TRUE);
1846
                  return FALSE;
1847
                }
1848
              idx = elf_section_data (elf_hash_table (info)->tls_sec)->dynindx;
1849
              ad += FRVFDPIC_TLS_BIAS;
1850
            }
1851
          _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1852
                                   _bfd_elf_section_offset
1853
                                   (output_bfd, info,
1854
                                    frvfdpic_got_section (info),
1855
                                    frvfdpic_got_initial_offset (info)
1856
                                    + entry->tlsoff_entry)
1857
                                   + frvfdpic_got_section (info)
1858
                                   ->output_section->vma
1859
                                   + frvfdpic_got_section (info)
1860
                                   ->output_offset,
1861
                                   R_FRV_TLSOFF, idx, ad, entry);
1862
        }
1863
 
1864
      bfd_put_32 (output_bfd, ad,
1865
                  frvfdpic_got_section (info)->contents
1866
                  + frvfdpic_got_initial_offset (info)
1867
                  + entry->tlsoff_entry);
1868
    }
1869
 
1870
  if (entry->tlsdesc_entry)
1871
    {
1872
      int idx = dynindx;
1873
      bfd_vma ad = addend;
1874
 
1875
      /* If the symbol is dynamic but binds locally, use
1876
         section+offset.  */
1877
      if (sec && (entry->symndx != -1
1878
                  || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1879
        {
1880
          if (entry->symndx == -1)
1881
            ad += entry->d.h->root.u.def.value;
1882
          else
1883
            ad += sym->st_value;
1884
          ad += sec->output_offset;
1885
          if (sec->output_section && elf_section_data (sec->output_section))
1886
            idx = elf_section_data (sec->output_section)->dynindx;
1887
          else
1888
            idx = 0;
1889
        }
1890
 
1891
      /* If we didn't set up a TLS offset entry, but we're linking an
1892
         executable and the symbol binds locally, we can use the
1893
         module offset in the TLS descriptor in relaxations.  */
1894
      if (info->executable && ! entry->tlsoff_entry)
1895
        entry->tlsoff_entry = entry->tlsdesc_entry + 4;
1896
 
1897
      if (info->executable && !info->pie
1898
          && ((idx == 0
1899
               && (bfd_is_abs_section (sec)
1900
                   || bfd_is_und_section (sec)))
1901
              || entry->symndx != -1
1902
              || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1903
        {
1904
          /* *ABS*+addend is special for TLS relocations, use only the
1905
             addend for the TLS offset, and take the module id as
1906
             0.  */
1907
          if (idx == 0
1908
              && (bfd_is_abs_section (sec)
1909
                  || bfd_is_und_section (sec)))
1910
            ;
1911
          /* For other TLS symbols that bind locally, add the section
1912
             TLS offset to the addend.  */
1913
          else if (sec)
1914
            ad += sec->output_section->vma - tls_biased_base (info);
1915
 
1916
          bfd_put_32 (output_bfd,
1917
                      frvfdpic_plt_section (info)->output_section->vma
1918
                      + frvfdpic_plt_section (info)->output_offset
1919
                      + frvfdpic_plt_tls_ret_offset (info),
1920
                      frvfdpic_got_section (info)->contents
1921
                      + frvfdpic_got_initial_offset (info)
1922
                      + entry->tlsdesc_entry);
1923
 
1924
          _frvfdpic_add_rofixup (output_bfd,
1925
                                 frvfdpic_gotfixup_section (info),
1926
                                 frvfdpic_got_section (info)
1927
                                 ->output_section->vma
1928
                                 + frvfdpic_got_section (info)
1929
                                 ->output_offset
1930
                                 + frvfdpic_got_initial_offset (info)
1931
                                 + entry->tlsdesc_entry, entry);
1932
 
1933
          BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs);
1934
 
1935
          /* We've used one of the reserved fixups, so discount it so
1936
             that we can check at the end that we've used them
1937
             all.  */
1938
          frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs--;
1939
 
1940
          /* While at that, make sure the ret instruction makes to the
1941
             right location in the PLT.  We could do it only when we
1942
             got to 0, but since the check at the end will only print
1943
             a warning, make sure we have the ret in place in case the
1944
             warning is missed.  */
1945
          bfd_put_32 (output_bfd, 0xc03a4000,
1946
                      frvfdpic_plt_section (info)->contents
1947
                      + frvfdpic_plt_tls_ret_offset (info));
1948
        }
1949
      else
1950
        {
1951
          if (idx == 0
1952
              && (bfd_is_abs_section (sec)
1953
                  || bfd_is_und_section (sec)))
1954
            {
1955
              if (! elf_hash_table (info)->tls_sec)
1956
                {
1957
                  (*info->callbacks->undefined_symbol)
1958
                    (info, "TLS section", elf_hash_table (info)->dynobj,
1959
                     frvfdpic_got_section (info), entry->tlsdesc_entry, TRUE);
1960
                  return FALSE;
1961
                }
1962
              idx = elf_section_data (elf_hash_table (info)->tls_sec)->dynindx;
1963
              ad += FRVFDPIC_TLS_BIAS;
1964
            }
1965
 
1966
          _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1967
                                   _bfd_elf_section_offset
1968
                                   (output_bfd, info,
1969
                                    frvfdpic_got_section (info),
1970
                                    frvfdpic_got_initial_offset (info)
1971
                                    + entry->tlsdesc_entry)
1972
                                   + frvfdpic_got_section (info)
1973
                                   ->output_section->vma
1974
                                   + frvfdpic_got_section (info)
1975
                                   ->output_offset,
1976
                                   R_FRV_TLSDESC_VALUE, idx, ad, entry);
1977
 
1978
          bfd_put_32 (output_bfd, 0,
1979
                      frvfdpic_got_section (info)->contents
1980
                      + frvfdpic_got_initial_offset (info)
1981
                      + entry->tlsdesc_entry);
1982
        }
1983
 
1984
      bfd_put_32 (output_bfd, ad,
1985
                  frvfdpic_got_section (info)->contents
1986
                  + frvfdpic_got_initial_offset (info)
1987
                  + entry->tlsdesc_entry + 4);
1988
    }
1989
 
1990
  /* Generate code for the get-TLS-offset PLT entry.  */
1991
  if (entry->tlsplt_entry != (bfd_vma) -1)
1992
    {
1993
      bfd_byte *plt_code = frvfdpic_plt_section (info)->contents
1994
        + entry->tlsplt_entry;
1995
 
1996
      if (info->executable
1997
          && (entry->symndx != -1
1998
              || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1999
        {
2000
          int idx = dynindx;
2001
          bfd_vma ad = addend;
2002
 
2003
          /* sec may be NULL when referencing an undefweak symbol
2004
             while linking a static executable.  */
2005
          if (!sec)
2006
            {
2007
              BFD_ASSERT (entry->symndx == -1
2008
                          && entry->d.h->root.type == bfd_link_hash_undefweak);
2009
            }
2010
          else
2011
            {
2012
              if (entry->symndx == -1)
2013
                ad += entry->d.h->root.u.def.value;
2014
              else
2015
                ad += sym->st_value;
2016
              ad += sec->output_offset;
2017
              if (sec->output_section
2018
                  && elf_section_data (sec->output_section))
2019
                idx = elf_section_data (sec->output_section)->dynindx;
2020
              else
2021
                idx = 0;
2022
            }
2023
 
2024
          /* *ABS*+addend is special for TLS relocations, use only the
2025
             addend for the TLS offset, and take the module id as
2026
             0.  */
2027
          if (idx == 0
2028
              && (bfd_is_abs_section (sec)
2029
                  || bfd_is_und_section (sec)))
2030
            ;
2031
          /* For other TLS symbols that bind locally, add the section
2032
             TLS offset to the addend.  */
2033
          else if (sec)
2034
            ad += sec->output_section->vma - tls_biased_base (info);
2035
 
2036
          if ((bfd_signed_vma)ad >= -(1 << (16 - 1))
2037
              && (bfd_signed_vma)ad < (1 << (16 - 1)))
2038
            {
2039
              /* setlos lo(ad), gr9 */
2040
              bfd_put_32 (output_bfd,
2041
                          0x92fc0000
2042
                          | (ad
2043
                             & (((bfd_vma)1 << 16) - 1)),
2044
                          plt_code);
2045
              plt_code += 4;
2046
            }
2047
          else
2048
            {
2049
              /* sethi.p hi(ad), gr9
2050
                 setlo lo(ad), gr9 */
2051
              bfd_put_32 (output_bfd,
2052
                          0x12f80000
2053
                          | ((ad >> 16)
2054
                             & (((bfd_vma)1 << 16) - 1)),
2055
                          plt_code);
2056
              plt_code += 4;
2057
              bfd_put_32 (output_bfd,
2058
                          0x92f40000
2059
                          | (ad
2060
                             & (((bfd_vma)1 << 16) - 1)),
2061
                          plt_code);
2062
              plt_code += 4;
2063
            }
2064
          /* ret */
2065
          bfd_put_32 (output_bfd, 0xc03a4000, plt_code);
2066
        }
2067
      else if (entry->tlsoff_entry)
2068
        {
2069
          /* Figure out what kind of PLT entry we need, depending on the
2070
             location of the TLS descriptor within the GOT.  */
2071
          if (entry->tlsoff_entry >= -(1 << (12 - 1))
2072
              && entry->tlsoff_entry < (1 << (12 - 1)))
2073
            {
2074
              /* ldi @(gr15, tlsoff_entry), gr9 */
2075
              bfd_put_32 (output_bfd,
2076
                          0x92c8f000 | (entry->tlsoff_entry
2077
                                        & ((1 << 12) - 1)),
2078
                          plt_code);
2079
              plt_code += 4;
2080
            }
2081
          else
2082
            {
2083
              if (entry->tlsoff_entry >= -(1 << (16 - 1))
2084
                  && entry->tlsoff_entry < (1 << (16 - 1)))
2085
                {
2086
                  /* setlos lo(tlsoff_entry), gr8 */
2087
                  bfd_put_32 (output_bfd,
2088
                              0x90fc0000
2089
                              | (entry->tlsoff_entry
2090
                                 & (((bfd_vma)1 << 16) - 1)),
2091
                              plt_code);
2092
                  plt_code += 4;
2093
                }
2094
              else
2095
                {
2096
                  /* sethi.p hi(tlsoff_entry), gr8
2097
                     setlo lo(tlsoff_entry), gr8 */
2098
                  bfd_put_32 (output_bfd,
2099
                              0x10f80000
2100
                              | ((entry->tlsoff_entry >> 16)
2101
                                 & (((bfd_vma)1 << 16) - 1)),
2102
                              plt_code);
2103
                  plt_code += 4;
2104
                  bfd_put_32 (output_bfd,
2105
                              0x90f40000
2106
                              | (entry->tlsoff_entry
2107
                                 & (((bfd_vma)1 << 16) - 1)),
2108
                              plt_code);
2109
                  plt_code += 4;
2110
                }
2111
              /* ld @(gr15,gr8),gr9 */
2112
              bfd_put_32 (output_bfd, 0x9008f108, plt_code);
2113
              plt_code += 4;
2114
            }
2115
          /* ret */
2116
          bfd_put_32 (output_bfd, 0xc03a4000, plt_code);
2117
        }
2118
      else
2119
        {
2120
          BFD_ASSERT (entry->tlsdesc_entry);
2121
 
2122
          /* Figure out what kind of PLT entry we need, depending on the
2123
             location of the TLS descriptor within the GOT.  */
2124
          if (entry->tlsdesc_entry >= -(1 << (12 - 1))
2125
              && entry->tlsdesc_entry < (1 << (12 - 1)))
2126
            {
2127
              /* lddi @(gr15, tlsdesc_entry), gr8 */
2128
              bfd_put_32 (output_bfd,
2129
                          0x90ccf000 | (entry->tlsdesc_entry
2130
                                        & ((1 << 12) - 1)),
2131
                          plt_code);
2132
              plt_code += 4;
2133
            }
2134
          else
2135
            {
2136
              if (entry->tlsdesc_entry >= -(1 << (16 - 1))
2137
                  && entry->tlsdesc_entry < (1 << (16 - 1)))
2138
                {
2139
                  /* setlos lo(tlsdesc_entry), gr8 */
2140
                  bfd_put_32 (output_bfd,
2141
                              0x90fc0000
2142
                              | (entry->tlsdesc_entry
2143
                                 & (((bfd_vma)1 << 16) - 1)),
2144
                              plt_code);
2145
                  plt_code += 4;
2146
                }
2147
              else
2148
                {
2149
                  /* sethi.p hi(tlsdesc_entry), gr8
2150
                     setlo lo(tlsdesc_entry), gr8 */
2151
                  bfd_put_32 (output_bfd,
2152
                              0x10f80000
2153
                              | ((entry->tlsdesc_entry >> 16)
2154
                                 & (((bfd_vma)1 << 16) - 1)),
2155
                              plt_code);
2156
                  plt_code += 4;
2157
                  bfd_put_32 (output_bfd,
2158
                              0x90f40000
2159
                              | (entry->tlsdesc_entry
2160
                                 & (((bfd_vma)1 << 16) - 1)),
2161
                              plt_code);
2162
                  plt_code += 4;
2163
                }
2164
              /* ldd @(gr15,gr8),gr8 */
2165
              bfd_put_32 (output_bfd, 0x9008f148, plt_code);
2166
              plt_code += 4;
2167
            }
2168
          /* jmpl @(gr8,gr0) */
2169
          bfd_put_32 (output_bfd, 0x80308000, plt_code);
2170
        }
2171
    }
2172
 
2173
  return TRUE;
2174
}
2175
 
2176
/* Handle an FRV small data reloc.  */
2177
 
2178
static bfd_reloc_status_type
2179
elf32_frv_relocate_gprel12 (info, input_bfd, input_section, relocation,
2180
                            contents, value)
2181
     struct bfd_link_info *info;
2182
     bfd *input_bfd;
2183
     asection *input_section;
2184
     Elf_Internal_Rela *relocation;
2185
     bfd_byte *contents;
2186
     bfd_vma value;
2187
{
2188
  bfd_vma insn;
2189
  bfd_vma gp;
2190
  struct bfd_link_hash_entry *h;
2191
 
2192
  h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2193
 
2194
  gp = (h->u.def.value
2195
        + h->u.def.section->output_section->vma
2196
        + h->u.def.section->output_offset);
2197
 
2198
  value -= input_section->output_section->vma;
2199
  value -= (gp - input_section->output_section->vma);
2200
 
2201
  insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
2202
 
2203
  value += relocation->r_addend;
2204
 
2205
  if ((long) value > 0x7ff || (long) value < -0x800)
2206
    return bfd_reloc_overflow;
2207
 
2208
  bfd_put_32 (input_bfd,
2209
              (insn & 0xfffff000) | (value & 0xfff),
2210
              contents + relocation->r_offset);
2211
 
2212
  return bfd_reloc_ok;
2213
}
2214
 
2215
/* Handle an FRV small data reloc. for the u12 field.  */
2216
 
2217
static bfd_reloc_status_type
2218
elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, relocation,
2219
                             contents, value)
2220
     struct bfd_link_info *info;
2221
     bfd *input_bfd;
2222
     asection *input_section;
2223
     Elf_Internal_Rela *relocation;
2224
     bfd_byte *contents;
2225
     bfd_vma value;
2226
{
2227
  bfd_vma insn;
2228
  bfd_vma gp;
2229
  struct bfd_link_hash_entry *h;
2230
  bfd_vma mask;
2231
 
2232
  h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2233
 
2234
  gp = (h->u.def.value
2235
        + h->u.def.section->output_section->vma
2236
        + h->u.def.section->output_offset);
2237
 
2238
  value -= input_section->output_section->vma;
2239
  value -= (gp - input_section->output_section->vma);
2240
 
2241
  insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
2242
 
2243
  value += relocation->r_addend;
2244
 
2245
  if ((long) value > 0x7ff || (long) value < -0x800)
2246
    return bfd_reloc_overflow;
2247
 
2248
  /* The high 6 bits go into bits 17-12. The low 6 bits go into bits 5-0.  */
2249
  mask = 0x3f03f;
2250
  insn = (insn & ~mask) | ((value & 0xfc0) << 12) | (value & 0x3f);
2251
 
2252
  bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
2253
 
2254
  return bfd_reloc_ok;
2255
}
2256
 
2257
/* Handle an FRV ELF HI16 reloc.  */
2258
 
2259
static bfd_reloc_status_type
2260
elf32_frv_relocate_hi16 (input_bfd, relhi, contents, value)
2261
     bfd *input_bfd;
2262
     Elf_Internal_Rela *relhi;
2263
     bfd_byte *contents;
2264
     bfd_vma value;
2265
{
2266
  bfd_vma insn;
2267
 
2268
  insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
2269
 
2270
  value += relhi->r_addend;
2271
  value = ((value >> 16) & 0xffff);
2272
 
2273
  insn = (insn & 0xffff0000) | value;
2274
 
2275
  if ((long) value > 0xffff || (long) value < -0x10000)
2276
    return bfd_reloc_overflow;
2277
 
2278
  bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
2279
  return bfd_reloc_ok;
2280
 
2281
}
2282
static bfd_reloc_status_type
2283
elf32_frv_relocate_lo16 (input_bfd, rello, contents, value)
2284
     bfd *input_bfd;
2285
     Elf_Internal_Rela *rello;
2286
     bfd_byte *contents;
2287
     bfd_vma value;
2288
{
2289
  bfd_vma insn;
2290
 
2291
  insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
2292
 
2293
  value += rello->r_addend;
2294
  value = value & 0xffff;
2295
 
2296
  insn = (insn & 0xffff0000) | value;
2297
 
2298
  if ((long) value > 0xffff || (long) value < -0x10000)
2299
    return bfd_reloc_overflow;
2300
 
2301
  bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
2302
  return bfd_reloc_ok;
2303
}
2304
 
2305
/* Perform the relocation for the CALL label24 instruction.  */
2306
 
2307
static bfd_reloc_status_type
2308
elf32_frv_relocate_label24 (input_bfd, input_section, rello, contents, value)
2309
     bfd *input_bfd;
2310
     asection *input_section;
2311
     Elf_Internal_Rela *rello;
2312
     bfd_byte *contents;
2313
     bfd_vma value;
2314
{
2315
  bfd_vma insn;
2316
  bfd_vma label6;
2317
  bfd_vma label18;
2318
 
2319
  /* The format for the call instruction is:
2320
 
2321
 
2322
      label6 opcode  label18
2323
 
2324
    The branch calculation is: pc + (4*label24)
2325
    where label24 is the concatenation of label6 and label18.  */
2326
 
2327
  /* Grab the instruction.  */
2328
  insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
2329
 
2330
  value -= input_section->output_section->vma + input_section->output_offset;
2331
  value -= rello->r_offset;
2332
  value += rello->r_addend;
2333
 
2334
  value = value >> 2;
2335
 
2336
  label6  = value & 0xfc0000;
2337
  label6  = label6 << 7;
2338
 
2339
  label18 = value & 0x3ffff;
2340
 
2341
  insn = insn & 0x803c0000;
2342
  insn = insn | label6;
2343
  insn = insn | label18;
2344
 
2345
  bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
2346
 
2347
  return bfd_reloc_ok;
2348
}
2349
 
2350
static bfd_reloc_status_type
2351
elf32_frv_relocate_gprelhi (info, input_bfd, input_section, relocation,
2352
                            contents, value)
2353
     struct bfd_link_info *info;
2354
     bfd *input_bfd;
2355
     asection *input_section;
2356
     Elf_Internal_Rela *relocation;
2357
     bfd_byte *contents;
2358
     bfd_vma value;
2359
{
2360
  bfd_vma insn;
2361
  bfd_vma gp;
2362
  struct bfd_link_hash_entry *h;
2363
 
2364
  h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2365
 
2366
  gp = (h->u.def.value
2367
        + h->u.def.section->output_section->vma
2368
        + h->u.def.section->output_offset);
2369
 
2370
  value -= input_section->output_section->vma;
2371
  value -= (gp - input_section->output_section->vma);
2372
  value += relocation->r_addend;
2373
  value = ((value >> 16) & 0xffff);
2374
 
2375
  if ((long) value > 0xffff || (long) value < -0x10000)
2376
    return bfd_reloc_overflow;
2377
 
2378
  insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
2379
  insn = (insn & 0xffff0000) | value;
2380
 
2381
  bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
2382
  return bfd_reloc_ok;
2383
}
2384
 
2385
static bfd_reloc_status_type
2386
elf32_frv_relocate_gprello (info, input_bfd, input_section, relocation,
2387
                            contents, value)
2388
     struct bfd_link_info *info;
2389
     bfd *input_bfd;
2390
     asection *input_section;
2391
     Elf_Internal_Rela *relocation;
2392
     bfd_byte *contents;
2393
     bfd_vma value;
2394
{
2395
  bfd_vma insn;
2396
  bfd_vma gp;
2397
  struct bfd_link_hash_entry *h;
2398
 
2399
  h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2400
 
2401
  gp = (h->u.def.value
2402
        + h->u.def.section->output_section->vma
2403
        + h->u.def.section->output_offset);
2404
 
2405
  value -= input_section->output_section->vma;
2406
  value -= (gp - input_section->output_section->vma);
2407
  value += relocation->r_addend;
2408
  value = value & 0xffff;
2409
 
2410
  if ((long) value > 0xffff || (long) value < -0x10000)
2411
    return bfd_reloc_overflow;
2412
 
2413
  insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
2414
  insn = (insn & 0xffff0000) | value;
2415
 
2416
  bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
2417
 
2418
 return bfd_reloc_ok;
2419
}
2420
 
2421
static reloc_howto_type *
2422
frv_reloc_type_lookup (abfd, code)
2423
     bfd *abfd ATTRIBUTE_UNUSED;
2424
     bfd_reloc_code_real_type code;
2425
{
2426
  switch (code)
2427
    {
2428
    default:
2429
      break;
2430
 
2431
    case BFD_RELOC_NONE:
2432
      return &elf32_frv_howto_table[ (int) R_FRV_NONE];
2433
 
2434
    case BFD_RELOC_32:
2435
      if (elf_elfheader (abfd)->e_type == ET_EXEC
2436
          || elf_elfheader (abfd)->e_type == ET_DYN)
2437
        return &elf32_frv_rel_32_howto;
2438
      /* Fall through.  */
2439
    case BFD_RELOC_CTOR:
2440
      return &elf32_frv_howto_table[ (int) R_FRV_32];
2441
 
2442
    case BFD_RELOC_FRV_LABEL16:
2443
      return &elf32_frv_howto_table[ (int) R_FRV_LABEL16];
2444
 
2445
    case BFD_RELOC_FRV_LABEL24:
2446
      return &elf32_frv_howto_table[ (int) R_FRV_LABEL24];
2447
 
2448
    case BFD_RELOC_FRV_LO16:
2449
      return &elf32_frv_howto_table[ (int) R_FRV_LO16];
2450
 
2451
    case BFD_RELOC_FRV_HI16:
2452
      return &elf32_frv_howto_table[ (int) R_FRV_HI16];
2453
 
2454
    case BFD_RELOC_FRV_GPREL12:
2455
      return &elf32_frv_howto_table[ (int) R_FRV_GPREL12];
2456
 
2457
    case BFD_RELOC_FRV_GPRELU12:
2458
      return &elf32_frv_howto_table[ (int) R_FRV_GPRELU12];
2459
 
2460
    case BFD_RELOC_FRV_GPREL32:
2461
      return &elf32_frv_howto_table[ (int) R_FRV_GPREL32];
2462
 
2463
    case BFD_RELOC_FRV_GPRELHI:
2464
      return &elf32_frv_howto_table[ (int) R_FRV_GPRELHI];
2465
 
2466
    case BFD_RELOC_FRV_GPRELLO:
2467
      return &elf32_frv_howto_table[ (int) R_FRV_GPRELLO];
2468
 
2469
    case BFD_RELOC_FRV_GOT12:
2470
      return &elf32_frv_howto_table[ (int) R_FRV_GOT12];
2471
 
2472
    case BFD_RELOC_FRV_GOTHI:
2473
      return &elf32_frv_howto_table[ (int) R_FRV_GOTHI];
2474
 
2475
    case BFD_RELOC_FRV_GOTLO:
2476
      return &elf32_frv_howto_table[ (int) R_FRV_GOTLO];
2477
 
2478
    case BFD_RELOC_FRV_FUNCDESC:
2479
      if (elf_elfheader (abfd)->e_type == ET_EXEC
2480
          || elf_elfheader (abfd)->e_type == ET_DYN)
2481
        return &elf32_frv_rel_funcdesc_howto;
2482
      return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC];
2483
 
2484
    case BFD_RELOC_FRV_FUNCDESC_GOT12:
2485
      return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOT12];
2486
 
2487
    case BFD_RELOC_FRV_FUNCDESC_GOTHI:
2488
      return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTHI];
2489
 
2490
    case BFD_RELOC_FRV_FUNCDESC_GOTLO:
2491
      return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTLO];
2492
 
2493
    case BFD_RELOC_FRV_FUNCDESC_VALUE:
2494
      if (elf_elfheader (abfd)->e_type == ET_EXEC
2495
          || elf_elfheader (abfd)->e_type == ET_DYN)
2496
        return &elf32_frv_rel_funcdesc_value_howto;
2497
      return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_VALUE];
2498
 
2499
    case BFD_RELOC_FRV_FUNCDESC_GOTOFF12:
2500
      return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFF12];
2501
 
2502
    case BFD_RELOC_FRV_FUNCDESC_GOTOFFHI:
2503
      return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFHI];
2504
 
2505
    case BFD_RELOC_FRV_FUNCDESC_GOTOFFLO:
2506
      return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFLO];
2507
 
2508
    case BFD_RELOC_FRV_GOTOFF12:
2509
      return &elf32_frv_howto_table[ (int) R_FRV_GOTOFF12];
2510
 
2511
    case BFD_RELOC_FRV_GOTOFFHI:
2512
      return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFHI];
2513
 
2514
    case BFD_RELOC_FRV_GOTOFFLO:
2515
      return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFLO];
2516
 
2517
    case BFD_RELOC_FRV_GETTLSOFF:
2518
      return &elf32_frv_howto_table[ (int) R_FRV_GETTLSOFF];
2519
 
2520
    case BFD_RELOC_FRV_TLSDESC_VALUE:
2521
      if (elf_elfheader (abfd)->e_type == ET_EXEC
2522
          || elf_elfheader (abfd)->e_type == ET_DYN)
2523
        return &elf32_frv_rel_tlsdesc_value_howto;
2524
      return &elf32_frv_howto_table[ (int) R_FRV_TLSDESC_VALUE];
2525
 
2526
    case BFD_RELOC_FRV_GOTTLSDESC12:
2527
      return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESC12];
2528
 
2529
    case BFD_RELOC_FRV_GOTTLSDESCHI:
2530
      return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESCHI];
2531
 
2532
    case BFD_RELOC_FRV_GOTTLSDESCLO:
2533
      return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESCLO];
2534
 
2535
    case BFD_RELOC_FRV_TLSMOFF12:
2536
      return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFF12];
2537
 
2538
    case BFD_RELOC_FRV_TLSMOFFHI:
2539
      return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFFHI];
2540
 
2541
    case BFD_RELOC_FRV_TLSMOFFLO:
2542
      return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFFLO];
2543
 
2544
    case BFD_RELOC_FRV_GOTTLSOFF12:
2545
      return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFF12];
2546
 
2547
    case BFD_RELOC_FRV_GOTTLSOFFHI:
2548
      return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFFHI];
2549
 
2550
    case BFD_RELOC_FRV_GOTTLSOFFLO:
2551
      return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFFLO];
2552
 
2553
    case BFD_RELOC_FRV_TLSOFF:
2554
      if (elf_elfheader (abfd)->e_type == ET_EXEC
2555
          || elf_elfheader (abfd)->e_type == ET_DYN)
2556
        return &elf32_frv_rel_tlsoff_howto;
2557
      return &elf32_frv_howto_table[ (int) R_FRV_TLSOFF];
2558
 
2559
    case BFD_RELOC_FRV_TLSDESC_RELAX:
2560
      return &elf32_frv_howto_table[ (int) R_FRV_TLSDESC_RELAX];
2561
 
2562
    case BFD_RELOC_FRV_GETTLSOFF_RELAX:
2563
      return &elf32_frv_howto_table[ (int) R_FRV_GETTLSOFF_RELAX];
2564
 
2565
    case BFD_RELOC_FRV_TLSOFF_RELAX:
2566
      return &elf32_frv_howto_table[ (int) R_FRV_TLSOFF_RELAX];
2567
 
2568
    case BFD_RELOC_FRV_TLSMOFF:
2569
      return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFF];
2570
 
2571
    case BFD_RELOC_VTABLE_INHERIT:
2572
      return &elf32_frv_vtinherit_howto;
2573
 
2574
    case BFD_RELOC_VTABLE_ENTRY:
2575
      return &elf32_frv_vtentry_howto;
2576
    }
2577
 
2578
  return NULL;
2579
}
2580
 
2581
static reloc_howto_type *
2582
frv_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
2583
{
2584
  unsigned int i;
2585
 
2586
  for (i = 0;
2587
       i < sizeof (elf32_frv_howto_table) / sizeof (elf32_frv_howto_table[0]);
2588
       i++)
2589
    if (elf32_frv_howto_table[i].name != NULL
2590
        && strcasecmp (elf32_frv_howto_table[i].name, r_name) == 0)
2591
      return &elf32_frv_howto_table[i];
2592
 
2593
  if (strcasecmp (elf32_frv_vtinherit_howto.name, r_name) == 0)
2594
    return &elf32_frv_vtinherit_howto;
2595
  if (strcasecmp (elf32_frv_vtentry_howto.name, r_name) == 0)
2596
    return &elf32_frv_vtentry_howto;
2597
 
2598
  return NULL;
2599
}
2600
 
2601
/* Set the howto pointer for an FRV ELF reloc.  */
2602
 
2603
static void
2604
frv_info_to_howto_rela (abfd, cache_ptr, dst)
2605
     bfd *abfd ATTRIBUTE_UNUSED;
2606
     arelent *cache_ptr;
2607
     Elf_Internal_Rela *dst;
2608
{
2609
  unsigned int r_type;
2610
 
2611
  r_type = ELF32_R_TYPE (dst->r_info);
2612
  switch (r_type)
2613
    {
2614
    case R_FRV_GNU_VTINHERIT:
2615
      cache_ptr->howto = &elf32_frv_vtinherit_howto;
2616
      break;
2617
 
2618
    case R_FRV_GNU_VTENTRY:
2619
      cache_ptr->howto = &elf32_frv_vtentry_howto;
2620
      break;
2621
 
2622
    default:
2623
      cache_ptr->howto = & elf32_frv_howto_table [r_type];
2624
      break;
2625
    }
2626
}
2627
 
2628
/* Set the howto pointer for an FRV ELF REL reloc.  */
2629
static void
2630
frvfdpic_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
2631
                            arelent *cache_ptr, Elf_Internal_Rela *dst)
2632
{
2633
  unsigned int r_type;
2634
 
2635
  r_type = ELF32_R_TYPE (dst->r_info);
2636
  switch (r_type)
2637
    {
2638
    case R_FRV_32:
2639
      cache_ptr->howto = &elf32_frv_rel_32_howto;
2640
      break;
2641
 
2642
    case R_FRV_FUNCDESC:
2643
      cache_ptr->howto = &elf32_frv_rel_funcdesc_howto;
2644
      break;
2645
 
2646
    case R_FRV_FUNCDESC_VALUE:
2647
      cache_ptr->howto = &elf32_frv_rel_funcdesc_value_howto;
2648
      break;
2649
 
2650
    case R_FRV_TLSDESC_VALUE:
2651
      cache_ptr->howto = &elf32_frv_rel_tlsdesc_value_howto;
2652
      break;
2653
 
2654
    case R_FRV_TLSOFF:
2655
      cache_ptr->howto = &elf32_frv_rel_tlsoff_howto;
2656
      break;
2657
 
2658
    default:
2659
      cache_ptr->howto = NULL;
2660
      break;
2661
    }
2662
}
2663
 
2664
/* Perform a single relocation.  By default we use the standard BFD
2665
   routines, but a few relocs, we have to do them ourselves.  */
2666
 
2667
static bfd_reloc_status_type
2668
frv_final_link_relocate (howto, input_bfd, input_section, contents, rel,
2669
                         relocation)
2670
     reloc_howto_type *howto;
2671
     bfd *input_bfd;
2672
     asection *input_section;
2673
     bfd_byte *contents;
2674
     Elf_Internal_Rela *rel;
2675
     bfd_vma relocation;
2676
{
2677
  return _bfd_final_link_relocate (howto, input_bfd, input_section,
2678
                                   contents, rel->r_offset, relocation,
2679
                                   rel->r_addend);
2680
}
2681
 
2682
 
2683
/* Relocate an FRV ELF section.
2684
 
2685
   The RELOCATE_SECTION function is called by the new ELF backend linker
2686
   to handle the relocations for a section.
2687
 
2688
   The relocs are always passed as Rela structures; if the section
2689
   actually uses Rel structures, the r_addend field will always be
2690
   zero.
2691
 
2692
   This function is responsible for adjusting the section contents as
2693
   necessary, and (if using Rela relocs and generating a relocatable
2694
   output file) adjusting the reloc addend as necessary.
2695
 
2696
   This function does not have to worry about setting the reloc
2697
   address or the reloc symbol index.
2698
 
2699
   LOCAL_SYMS is a pointer to the swapped in local symbols.
2700
 
2701
   LOCAL_SECTIONS is an array giving the section in the input file
2702
   corresponding to the st_shndx field of each local symbol.
2703
 
2704
   The global hash table entry for the global symbols can be found
2705
   via elf_sym_hashes (input_bfd).
2706
 
2707
   When generating relocatable output, this function must handle
2708
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2709
   going to be the section symbol corresponding to the output
2710
   section, which means that the addend must be adjusted
2711
   accordingly.  */
2712
 
2713
static bfd_boolean
2714
elf32_frv_relocate_section (output_bfd, info, input_bfd, input_section,
2715
                            contents, relocs, local_syms, local_sections)
2716
     bfd *output_bfd ATTRIBUTE_UNUSED;
2717
     struct bfd_link_info *info;
2718
     bfd *input_bfd;
2719
     asection *input_section;
2720
     bfd_byte *contents;
2721
     Elf_Internal_Rela *relocs;
2722
     Elf_Internal_Sym *local_syms;
2723
     asection **local_sections;
2724
{
2725
  Elf_Internal_Shdr *symtab_hdr;
2726
  struct elf_link_hash_entry **sym_hashes;
2727
  Elf_Internal_Rela *rel;
2728
  Elf_Internal_Rela *relend;
2729
  unsigned isec_segment, got_segment, plt_segment, gprel_segment, tls_segment,
2730
    check_segment[2];
2731
  int silence_segment_error = !(info->shared || info->pie);
2732
  unsigned long insn;
2733
 
2734
  symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2735
  sym_hashes = elf_sym_hashes (input_bfd);
2736
  relend     = relocs + input_section->reloc_count;
2737
 
2738
  isec_segment = _frvfdpic_osec_to_segment (output_bfd,
2739
                                            input_section->output_section);
2740
  if (IS_FDPIC (output_bfd) && frvfdpic_got_section (info))
2741
    got_segment = _frvfdpic_osec_to_segment (output_bfd,
2742
                                             frvfdpic_got_section (info)
2743
                                             ->output_section);
2744
  else
2745
    got_segment = -1;
2746
  if (IS_FDPIC (output_bfd) && frvfdpic_gotfixup_section (info))
2747
    gprel_segment = _frvfdpic_osec_to_segment (output_bfd,
2748
                                               frvfdpic_gotfixup_section (info)
2749
                                               ->output_section);
2750
  else
2751
    gprel_segment = -1;
2752
  if (IS_FDPIC (output_bfd) && frvfdpic_plt_section (info))
2753
    plt_segment = _frvfdpic_osec_to_segment (output_bfd,
2754
                                             frvfdpic_plt_section (info)
2755
                                             ->output_section);
2756
  else
2757
    plt_segment = -1;
2758
  if (elf_hash_table (info)->tls_sec)
2759
    tls_segment = _frvfdpic_osec_to_segment (output_bfd,
2760
                                             elf_hash_table (info)->tls_sec);
2761
  else
2762
    tls_segment = -1;
2763
 
2764
  for (rel = relocs; rel < relend; rel ++)
2765
    {
2766
      reloc_howto_type *howto;
2767
      unsigned long r_symndx;
2768
      Elf_Internal_Sym *sym;
2769
      asection *sec;
2770
      struct elf_link_hash_entry *h;
2771
      bfd_vma relocation;
2772
      bfd_reloc_status_type r;
2773
      const char * name = NULL;
2774
      int r_type;
2775
      asection *osec;
2776
      struct frvfdpic_relocs_info *picrel;
2777
      bfd_vma orig_addend = rel->r_addend;
2778
 
2779
      r_type = ELF32_R_TYPE (rel->r_info);
2780
 
2781
      if (   r_type == R_FRV_GNU_VTINHERIT
2782
          || r_type == R_FRV_GNU_VTENTRY)
2783
        continue;
2784
 
2785
      r_symndx = ELF32_R_SYM (rel->r_info);
2786
      howto  = elf32_frv_howto_table + ELF32_R_TYPE (rel->r_info);
2787
      h      = NULL;
2788
      sym    = NULL;
2789
      sec    = NULL;
2790
 
2791
      if (r_symndx < symtab_hdr->sh_info)
2792
        {
2793
          sym = local_syms + r_symndx;
2794
          osec = sec = local_sections [r_symndx];
2795
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2796
 
2797
          name = bfd_elf_string_from_elf_section
2798
            (input_bfd, symtab_hdr->sh_link, sym->st_name);
2799
          name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
2800
        }
2801
      else
2802
        {
2803
          bfd_boolean warned;
2804
          bfd_boolean unresolved_reloc;
2805
 
2806
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2807
                                   r_symndx, symtab_hdr, sym_hashes,
2808
                                   h, sec, relocation,
2809
                                   unresolved_reloc, warned);
2810
          osec = sec;
2811
        }
2812
 
2813
      if (sec != NULL && elf_discarded_section (sec))
2814
        {
2815
          /* For relocs against symbols from removed linkonce sections,
2816
             or sections discarded by a linker script, we just want the
2817
             section contents zeroed.  Avoid any special processing.  */
2818
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2819
          rel->r_info = 0;
2820
          rel->r_addend = 0;
2821
          continue;
2822
        }
2823
 
2824
      if (info->relocatable)
2825
        continue;
2826
 
2827
      if (r_type != R_FRV_TLSMOFF
2828
          && h != NULL
2829
          && (h->root.type == bfd_link_hash_defined
2830
              || h->root.type == bfd_link_hash_defweak)
2831
          && !FRVFDPIC_SYM_LOCAL (info, h))
2832
        {
2833
          osec = sec = NULL;
2834
          relocation = 0;
2835
        }
2836
 
2837
      switch (r_type)
2838
        {
2839
        case R_FRV_LABEL24:
2840
        case R_FRV_32:
2841
          if (! IS_FDPIC (output_bfd))
2842
            goto non_fdpic;
2843
 
2844
        case R_FRV_GOT12:
2845
        case R_FRV_GOTHI:
2846
        case R_FRV_GOTLO:
2847
        case R_FRV_FUNCDESC_GOT12:
2848
        case R_FRV_FUNCDESC_GOTHI:
2849
        case R_FRV_FUNCDESC_GOTLO:
2850
        case R_FRV_GOTOFF12:
2851
        case R_FRV_GOTOFFHI:
2852
        case R_FRV_GOTOFFLO:
2853
        case R_FRV_FUNCDESC_GOTOFF12:
2854
        case R_FRV_FUNCDESC_GOTOFFHI:
2855
        case R_FRV_FUNCDESC_GOTOFFLO:
2856
        case R_FRV_FUNCDESC:
2857
        case R_FRV_FUNCDESC_VALUE:
2858
        case R_FRV_GETTLSOFF:
2859
        case R_FRV_TLSDESC_VALUE:
2860
        case R_FRV_GOTTLSDESC12:
2861
        case R_FRV_GOTTLSDESCHI:
2862
        case R_FRV_GOTTLSDESCLO:
2863
        case R_FRV_TLSMOFF12:
2864
        case R_FRV_TLSMOFFHI:
2865
        case R_FRV_TLSMOFFLO:
2866
        case R_FRV_GOTTLSOFF12:
2867
        case R_FRV_GOTTLSOFFHI:
2868
        case R_FRV_GOTTLSOFFLO:
2869
        case R_FRV_TLSOFF:
2870
        case R_FRV_TLSDESC_RELAX:
2871
        case R_FRV_GETTLSOFF_RELAX:
2872
        case R_FRV_TLSOFF_RELAX:
2873
        case R_FRV_TLSMOFF:
2874
          if (h != NULL)
2875
            picrel = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info
2876
                                                      (info), input_bfd, h,
2877
                                                      orig_addend, INSERT);
2878
          else
2879
            /* In order to find the entry we created before, we must
2880
               use the original addend, not the one that may have been
2881
               modified by _bfd_elf_rela_local_sym().  */
2882
            picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
2883
                                                     (info), input_bfd, r_symndx,
2884
                                                     orig_addend, INSERT);
2885
          if (! picrel)
2886
            return FALSE;
2887
 
2888
          if (!_frvfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info,
2889
                                                      osec, sym,
2890
                                                      rel->r_addend))
2891
            {
2892
              (*_bfd_error_handler)
2893
                (_("%B(%A+0x%x): relocation to `%s+%x' may have caused the error above"),
2894
                 input_bfd, input_section, rel->r_offset, name, rel->r_addend);
2895
              return FALSE;
2896
            }
2897
 
2898
          break;
2899
 
2900
        default:
2901
        non_fdpic:
2902
          picrel = NULL;
2903
          if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
2904
            {
2905
              info->callbacks->warning
2906
                (info, _("relocation references symbol not defined in the module"),
2907
                 name, input_bfd, input_section, rel->r_offset);
2908
              return FALSE;
2909
            }
2910
          break;
2911
        }
2912
 
2913
      switch (r_type)
2914
        {
2915
        case R_FRV_GETTLSOFF:
2916
        case R_FRV_TLSDESC_VALUE:
2917
        case R_FRV_GOTTLSDESC12:
2918
        case R_FRV_GOTTLSDESCHI:
2919
        case R_FRV_GOTTLSDESCLO:
2920
        case R_FRV_TLSMOFF12:
2921
        case R_FRV_TLSMOFFHI:
2922
        case R_FRV_TLSMOFFLO:
2923
        case R_FRV_GOTTLSOFF12:
2924
        case R_FRV_GOTTLSOFFHI:
2925
        case R_FRV_GOTTLSOFFLO:
2926
        case R_FRV_TLSOFF:
2927
        case R_FRV_TLSDESC_RELAX:
2928
        case R_FRV_GETTLSOFF_RELAX:
2929
        case R_FRV_TLSOFF_RELAX:
2930
        case R_FRV_TLSMOFF:
2931
          if (sec && (bfd_is_abs_section (sec) || bfd_is_und_section (sec)))
2932
            relocation += tls_biased_base (info);
2933
          break;
2934
 
2935
        default:
2936
          break;
2937
        }
2938
 
2939
      /* Try to apply TLS relaxations.  */
2940
      if (1)
2941
        switch (r_type)
2942
          {
2943
 
2944
#define LOCAL_EXEC_P(info, picrel) \
2945
  ((info)->executable \
2946
   && (picrel->symndx != -1 || FRVFDPIC_SYM_LOCAL ((info), (picrel)->d.h)))
2947
#define INITIAL_EXEC_P(info, picrel) \
2948
  (((info)->executable || (info)->flags & DF_STATIC_TLS) \
2949
   && (picrel)->tlsoff_entry)
2950
 
2951
#define IN_RANGE_FOR_OFST12_P(value) \
2952
  ((bfd_vma)((value) + 2048) < (bfd_vma)4096)
2953
#define IN_RANGE_FOR_SETLOS_P(value) \
2954
  ((bfd_vma)((value) + 32768) < (bfd_vma)65536)
2955
#define TLSMOFF_IN_RANGE_FOR_SETLOS_P(value, info) \
2956
  (IN_RANGE_FOR_SETLOS_P ((value) - tls_biased_base (info)))
2957
 
2958
#define RELAX_GETTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2959
  (LOCAL_EXEC_P ((info), (picrel)) \
2960
   && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2961
#define RELAX_GETTLSOFF_INITIAL_EXEC_P(info, picrel) \
2962
  (INITIAL_EXEC_P ((info), (picrel)) \
2963
   && IN_RANGE_FOR_OFST12_P ((picrel)->tlsoff_entry))
2964
 
2965
#define RELAX_TLSDESC_LOCAL_EXEC_P(info, picrel, value) \
2966
  (LOCAL_EXEC_P ((info), (picrel)))
2967
#define RELAX_TLSDESC_INITIAL_EXEC_P(info, picrel) \
2968
  (INITIAL_EXEC_P ((info), (picrel)))
2969
 
2970
#define RELAX_GOTTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2971
  (LOCAL_EXEC_P ((info), (picrel)) \
2972
   && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2973
 
2974
          case R_FRV_GETTLSOFF:
2975
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2976
 
2977
            /* Is this a call instruction?  */
2978
            if ((insn & (unsigned long)0x01fc0000) != 0x003c0000)
2979
              {
2980
                r = info->callbacks->warning
2981
                  (info,
2982
                   _("R_FRV_GETTLSOFF not applied to a call instruction"),
2983
                   name, input_bfd, input_section, rel->r_offset);
2984
                return FALSE;
2985
              }
2986
 
2987
            if (RELAX_GETTLSOFF_LOCAL_EXEC_P (info, picrel,
2988
                                              relocation + rel->r_addend))
2989
              {
2990
                /* Replace the call instruction (except the packing bit)
2991
                   with setlos #tlsmofflo(symbol+offset), gr9.  */
2992
                insn &= (unsigned long)0x80000000;
2993
                insn |= (unsigned long)0x12fc0000;
2994
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2995
 
2996
                r_type = R_FRV_TLSMOFFLO;
2997
                howto  = elf32_frv_howto_table + r_type;
2998
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
2999
              }
3000
 
3001
            else if (RELAX_GETTLSOFF_INITIAL_EXEC_P (info, picrel))
3002
              {
3003
                /* Replace the call instruction (except the packing bit)
3004
                   with ldi @(gr15, #gottlsoff12(symbol+addend)), gr9.  */
3005
                insn &= (unsigned long)0x80000000;
3006
                insn |= (unsigned long)0x12c8f000;
3007
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3008
 
3009
                r_type = R_FRV_GOTTLSOFF12;
3010
                howto  = elf32_frv_howto_table + r_type;
3011
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3012
              }
3013
 
3014
            break;
3015
 
3016
          case R_FRV_GOTTLSDESC12:
3017
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3018
 
3019
            /* Is this an lddi instruction?  */
3020
            if ((insn & (unsigned long)0x01fc0000) != 0x00cc0000)
3021
              {
3022
                r = info->callbacks->warning
3023
                  (info,
3024
                   _("R_FRV_GOTTLSDESC12 not applied to an lddi instruction"),
3025
                   name, input_bfd, input_section, rel->r_offset);
3026
                return FALSE;
3027
              }
3028
 
3029
            if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3030
                                            relocation + rel->r_addend)
3031
                && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3032
                                                  info))
3033
              {
3034
                /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3035
                   with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3036
                   Preserve the packing bit.  */
3037
                insn = (insn & (unsigned long)0x80000000)
3038
                  | ((insn + (unsigned long)0x02000000)
3039
                     & (unsigned long)0x7e000000);
3040
                insn |= (unsigned long)0x00fc0000;
3041
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3042
 
3043
                r_type = R_FRV_TLSMOFFLO;
3044
                howto  = elf32_frv_howto_table + r_type;
3045
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3046
              }
3047
 
3048
            else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3049
                                                 relocation + rel->r_addend))
3050
              {
3051
                /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3052
                   with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3053
                   Preserve the packing bit.  */
3054
                insn = (insn & (unsigned long)0x80000000)
3055
                  | ((insn + (unsigned long)0x02000000)
3056
                     & (unsigned long)0x7e000000);
3057
                insn |= (unsigned long)0x00f80000;
3058
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3059
 
3060
                r_type = R_FRV_TLSMOFFHI;
3061
                howto  = elf32_frv_howto_table + r_type;
3062
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3063
              }
3064
 
3065
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3066
              {
3067
                /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3068
                   with ldi @(grB, #gottlsoff12(symbol+offset),
3069
                   gr<C+1>.  Preserve the packing bit.  If gottlsoff12
3070
                   overflows, we'll error out, but that's sort-of ok,
3071
                   since we'd started with gottlsdesc12, that's actually
3072
                   more demanding.  Compiling with -fPIE instead of
3073
                   -fpie would fix it; linking with --relax should fix
3074
                   it as well.  */
3075
                insn = (insn & (unsigned long)0x80cbf000)
3076
                  | ((insn + (unsigned long)0x02000000)
3077
                     & (unsigned long)0x7e000000);
3078
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3079
 
3080
                r_type = R_FRV_GOTTLSOFF12;
3081
                howto  = elf32_frv_howto_table + r_type;
3082
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3083
              }
3084
 
3085
            break;
3086
 
3087
          case R_FRV_GOTTLSDESCHI:
3088
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3089
 
3090
            /* Is this a sethi instruction?  */
3091
            if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3092
              {
3093
                r = info->callbacks->warning
3094
                  (info,
3095
                   _("R_FRV_GOTTLSDESCHI not applied to a sethi instruction"),
3096
                   name, input_bfd, input_section, rel->r_offset);
3097
                return FALSE;
3098
              }
3099
 
3100
            if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3101
                                            relocation + rel->r_addend)
3102
                || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3103
                    && IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry)))
3104
              {
3105
                /* Replace sethi with a nop.  Preserve the packing bit.  */
3106
                insn &= (unsigned long)0x80000000;
3107
                insn |= (unsigned long)0x00880000;
3108
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3109
 
3110
                /* Nothing to relocate.  */
3111
                continue;
3112
              }
3113
 
3114
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3115
              {
3116
                /* Simply decay GOTTLSDESC to GOTTLSOFF.  */
3117
                r_type = R_FRV_GOTTLSOFFHI;
3118
                howto  = elf32_frv_howto_table + r_type;
3119
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3120
              }
3121
 
3122
            break;
3123
 
3124
          case R_FRV_GOTTLSDESCLO:
3125
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3126
 
3127
            /* Is this a setlo or setlos instruction?  */
3128
            if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3129
              {
3130
                r = info->callbacks->warning
3131
                  (info,
3132
                   _("R_FRV_GOTTLSDESCLO"
3133
                     " not applied to a setlo or setlos instruction"),
3134
                   name, input_bfd, input_section, rel->r_offset);
3135
                return FALSE;
3136
              }
3137
 
3138
            if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3139
                                            relocation + rel->r_addend)
3140
                || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3141
                    && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3142
              {
3143
                /* Replace setlo/setlos with a nop.  Preserve the
3144
                   packing bit.  */
3145
                insn &= (unsigned long)0x80000000;
3146
                insn |= (unsigned long)0x00880000;
3147
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3148
 
3149
                /* Nothing to relocate.  */
3150
                continue;
3151
              }
3152
 
3153
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3154
              {
3155
                /* If the corresponding sethi (if it exists) decayed
3156
                   to a nop, make sure this becomes (or already is) a
3157
                   setlos, not setlo.  */
3158
                if (IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry))
3159
                  {
3160
                    insn |= (unsigned long)0x00080000;
3161
                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3162
                  }
3163
 
3164
                /* Simply decay GOTTLSDESC to GOTTLSOFF.  */
3165
                r_type = R_FRV_GOTTLSOFFLO;
3166
                howto  = elf32_frv_howto_table + r_type;
3167
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3168
              }
3169
 
3170
            break;
3171
 
3172
          case R_FRV_TLSDESC_RELAX:
3173
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3174
 
3175
            /* Is this an ldd instruction?  */
3176
            if ((insn & (unsigned long)0x01fc0fc0) != 0x00080140)
3177
              {
3178
                r = info->callbacks->warning
3179
                  (info,
3180
                   _("R_FRV_TLSDESC_RELAX not applied to an ldd instruction"),
3181
                   name, input_bfd, input_section, rel->r_offset);
3182
                return FALSE;
3183
              }
3184
 
3185
            if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3186
                                            relocation + rel->r_addend)
3187
                && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3188
                                                  info))
3189
              {
3190
                /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3191
                   with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3192
                   Preserve the packing bit.  */
3193
                insn = (insn & (unsigned long)0x80000000)
3194
                  | ((insn + (unsigned long)0x02000000)
3195
                     & (unsigned long)0x7e000000);
3196
                insn |= (unsigned long)0x00fc0000;
3197
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3198
 
3199
                r_type = R_FRV_TLSMOFFLO;
3200
                howto  = elf32_frv_howto_table + r_type;
3201
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3202
              }
3203
 
3204
            else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3205
                                                 relocation + rel->r_addend))
3206
              {
3207
                /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3208
                   with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3209
                   Preserve the packing bit.  */
3210
                insn = (insn & (unsigned long)0x80000000)
3211
                  | ((insn + (unsigned long)0x02000000)
3212
                     & (unsigned long)0x7e000000);
3213
                insn |= (unsigned long)0x00f80000;
3214
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3215
 
3216
                r_type = R_FRV_TLSMOFFHI;
3217
                howto  = elf32_frv_howto_table + r_type;
3218
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3219
              }
3220
 
3221
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3222
                     && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))
3223
              {
3224
                /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3225
                   with ldi @(grB, #gottlsoff12(symbol+offset), gr<C+1>.
3226
                   Preserve the packing bit.  */
3227
                insn = (insn & (unsigned long)0x8003f000)
3228
                  | (unsigned long)0x00c80000
3229
                  | ((insn + (unsigned long)0x02000000)
3230
                     & (unsigned long)0x7e000000);
3231
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3232
 
3233
                r_type = R_FRV_GOTTLSOFF12;
3234
                howto  = elf32_frv_howto_table + r_type;
3235
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3236
              }
3237
 
3238
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3239
              {
3240
                /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3241
                   with ld #tlsoff(symbol+offset)@(grB, grA), gr<C+1>.
3242
                   Preserve the packing bit.  */
3243
                insn = (insn & (unsigned long)0x81ffffbf)
3244
                  | ((insn + (unsigned long)0x02000000)
3245
                     & (unsigned long)0x7e000000);
3246
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3247
 
3248
                /* #tlsoff(symbol+offset) is just a relaxation
3249
                    annotation, so there's nothing left to
3250
                    relocate.  */
3251
                continue;
3252
              }
3253
 
3254
            break;
3255
 
3256
          case R_FRV_GETTLSOFF_RELAX:
3257
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3258
 
3259
            /* Is this a calll or callil instruction?  */
3260
            if ((insn & (unsigned long)0x7ff80fc0) != 0x02300000)
3261
              {
3262
                r = info->callbacks->warning
3263
                  (info,
3264
                   _("R_FRV_GETTLSOFF_RELAX"
3265
                     " not applied to a calll instruction"),
3266
                   name, input_bfd, input_section, rel->r_offset);
3267
                return FALSE;
3268
              }
3269
 
3270
            if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3271
                                            relocation + rel->r_addend)
3272
                && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3273
                                                  info))
3274
              {
3275
                /* Replace calll with a nop.  Preserve the packing bit.  */
3276
                insn &= (unsigned long)0x80000000;
3277
                insn |= (unsigned long)0x00880000;
3278
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3279
 
3280
                /* Nothing to relocate.  */
3281
                continue;
3282
              }
3283
 
3284
            else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3285
                                                 relocation + rel->r_addend))
3286
              {
3287
                /* Replace calll with setlo #tlsmofflo(symbol+offset), gr9.
3288
                   Preserve the packing bit.  */
3289
                insn &= (unsigned long)0x80000000;
3290
                insn |= (unsigned long)0x12f40000;
3291
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3292
 
3293
                r_type = R_FRV_TLSMOFFLO;
3294
                howto  = elf32_frv_howto_table + r_type;
3295
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3296
              }
3297
 
3298
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3299
              {
3300
                /* Replace calll with a nop.  Preserve the packing bit.  */
3301
                insn &= (unsigned long)0x80000000;
3302
                insn |= (unsigned long)0x00880000;
3303
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3304
 
3305
                /* Nothing to relocate.  */
3306
                continue;
3307
              }
3308
 
3309
            break;
3310
 
3311
          case R_FRV_GOTTLSOFF12:
3312
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3313
 
3314
            /* Is this an ldi instruction?  */
3315
            if ((insn & (unsigned long)0x01fc0000) != 0x00c80000)
3316
              {
3317
                r = info->callbacks->warning
3318
                  (info,
3319
                   _("R_FRV_GOTTLSOFF12 not applied to an ldi instruction"),
3320
                   name, input_bfd, input_section, rel->r_offset);
3321
                return FALSE;
3322
              }
3323
 
3324
            if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3325
                                              relocation + rel->r_addend))
3326
              {
3327
                /* Replace ldi @(grB, #gottlsoff12(symbol+offset), grC
3328
                   with setlos #tlsmofflo(symbol+offset), grC.
3329
                   Preserve the packing bit.  */
3330
                insn &= (unsigned long)0xfe000000;
3331
                insn |= (unsigned long)0x00fc0000;
3332
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3333
 
3334
                r_type = R_FRV_TLSMOFFLO;
3335
                howto  = elf32_frv_howto_table + r_type;
3336
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3337
              }
3338
 
3339
            break;
3340
 
3341
          case R_FRV_GOTTLSOFFHI:
3342
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3343
 
3344
            /* Is this a sethi instruction?  */
3345
            if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3346
              {
3347
                r = info->callbacks->warning
3348
                  (info,
3349
                   _("R_FRV_GOTTLSOFFHI not applied to a sethi instruction"),
3350
                   name, input_bfd, input_section, rel->r_offset);
3351
                return FALSE;
3352
              }
3353
 
3354
            if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3355
                                              relocation + rel->r_addend)
3356
                || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3357
                    && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3358
              {
3359
                /* Replace sethi with a nop.  Preserve the packing bit.  */
3360
                insn &= (unsigned long)0x80000000;
3361
                insn |= (unsigned long)0x00880000;
3362
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3363
 
3364
                /* Nothing to relocate.  */
3365
                continue;
3366
              }
3367
 
3368
            break;
3369
 
3370
          case R_FRV_GOTTLSOFFLO:
3371
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3372
 
3373
            /* Is this a setlo or setlos instruction?  */
3374
            if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3375
              {
3376
                r = info->callbacks->warning
3377
                  (info,
3378
                   _("R_FRV_GOTTLSOFFLO"
3379
                     " not applied to a setlo or setlos instruction"),
3380
                   name, input_bfd, input_section, rel->r_offset);
3381
                return FALSE;
3382
              }
3383
 
3384
            if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3385
                                              relocation + rel->r_addend)
3386
                || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3387
                    && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3388
              {
3389
                /* Replace setlo/setlos with a nop.  Preserve the
3390
                   packing bit.  */
3391
                insn &= (unsigned long)0x80000000;
3392
                insn |= (unsigned long)0x00880000;
3393
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3394
 
3395
                /* Nothing to relocate.  */
3396
                continue;
3397
              }
3398
 
3399
            break;
3400
 
3401
          case R_FRV_TLSOFF_RELAX:
3402
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3403
 
3404
            /* Is this an ld instruction?  */
3405
            if ((insn & (unsigned long)0x01fc0fc0) != 0x00080100)
3406
              {
3407
                r = info->callbacks->warning
3408
                  (info,
3409
                   _("R_FRV_TLSOFF_RELAX not applied to an ld instruction"),
3410
                   name, input_bfd, input_section, rel->r_offset);
3411
                return FALSE;
3412
              }
3413
 
3414
            if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3415
                                              relocation + rel->r_addend))
3416
              {
3417
                /* Replace ld #gottlsoff(symbol+offset)@(grB, grA), grC
3418
                   with setlos #tlsmofflo(symbol+offset), grC.
3419
                   Preserve the packing bit.  */
3420
                insn &= (unsigned long)0xfe000000;
3421
                insn |= (unsigned long)0x00fc0000;
3422
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3423
 
3424
                r_type = R_FRV_TLSMOFFLO;
3425
                howto  = elf32_frv_howto_table + r_type;
3426
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3427
              }
3428
 
3429
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3430
                     && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))
3431
              {
3432
                /* Replace ld #tlsoff(symbol+offset)@(grB, grA), grC
3433
                   with ldi @(grB, #gottlsoff12(symbol+offset), grC.
3434
                   Preserve the packing bit.  */
3435
                insn = (insn & (unsigned long)0xfe03f000)
3436
                  | (unsigned long)0x00c80000;;
3437
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3438
 
3439
                r_type = R_FRV_GOTTLSOFF12;
3440
                howto  = elf32_frv_howto_table + r_type;
3441
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3442
              }
3443
 
3444
            break;
3445
 
3446
          case R_FRV_TLSMOFFHI:
3447
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3448
 
3449
            /* Is this a sethi instruction?  */
3450
            if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3451
              {
3452
                r = info->callbacks->warning
3453
                  (info,
3454
                   _("R_FRV_TLSMOFFHI not applied to a sethi instruction"),
3455
                   name, input_bfd, input_section, rel->r_offset);
3456
                return FALSE;
3457
              }
3458
 
3459
            if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3460
                                               info))
3461
              {
3462
                /* Replace sethi with a nop.  Preserve the packing bit.  */
3463
                insn &= (unsigned long)0x80000000;
3464
                insn |= (unsigned long)0x00880000;
3465
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3466
 
3467
                /* Nothing to relocate.  */
3468
                continue;
3469
              }
3470
 
3471
            break;
3472
 
3473
          case R_FRV_TLSMOFFLO:
3474
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3475
 
3476
            /* Is this a setlo or setlos instruction?  */
3477
            if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3478
              {
3479
                r = info->callbacks->warning
3480
                  (info,
3481
                   _("R_FRV_TLSMOFFLO"
3482
                     " not applied to a setlo or setlos instruction"),
3483
                   name, input_bfd, input_section, rel->r_offset);
3484
                return FALSE;
3485
              }
3486
 
3487
            if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3488
                                               info))
3489
              /* If the corresponding sethi (if it exists) decayed
3490
                 to a nop, make sure this becomes (or already is) a
3491
                 setlos, not setlo.  */
3492
              {
3493
                insn |= (unsigned long)0x00080000;
3494
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3495
              }
3496
 
3497
            break;
3498
 
3499
            /*
3500
              There's nothing to relax in these:
3501
                R_FRV_TLSDESC_VALUE
3502
                R_FRV_TLSOFF
3503
                R_FRV_TLSMOFF12
3504
                R_FRV_TLSMOFFHI
3505
                R_FRV_TLSMOFFLO
3506
                R_FRV_TLSMOFF
3507
            */
3508
 
3509
          default:
3510
            break;
3511
          }
3512
 
3513
      switch (r_type)
3514
        {
3515
        case R_FRV_LABEL24:
3516
          check_segment[0] = isec_segment;
3517
          if (! IS_FDPIC (output_bfd))
3518
            check_segment[1] = isec_segment;
3519
          else if (picrel->plt)
3520
            {
3521
              relocation = frvfdpic_plt_section (info)->output_section->vma
3522
                + frvfdpic_plt_section (info)->output_offset
3523
                + picrel->plt_entry;
3524
              check_segment[1] = plt_segment;
3525
            }
3526
          /* We don't want to warn on calls to undefined weak symbols,
3527
             as calls to them must be protected by non-NULL tests
3528
             anyway, and unprotected calls would invoke undefined
3529
             behavior.  */
3530
          else if (picrel->symndx == -1
3531
                   && picrel->d.h->root.type == bfd_link_hash_undefweak)
3532
            check_segment[1] = check_segment[0];
3533
          else
3534
            check_segment[1] = sec
3535
              ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3536
              : (unsigned)-1;
3537
          break;
3538
 
3539
        case R_FRV_GOT12:
3540
        case R_FRV_GOTHI:
3541
        case R_FRV_GOTLO:
3542
          relocation = picrel->got_entry;
3543
          check_segment[0] = check_segment[1] = got_segment;
3544
          break;
3545
 
3546
        case R_FRV_FUNCDESC_GOT12:
3547
        case R_FRV_FUNCDESC_GOTHI:
3548
        case R_FRV_FUNCDESC_GOTLO:
3549
          relocation = picrel->fdgot_entry;
3550
          check_segment[0] = check_segment[1] = got_segment;
3551
          break;
3552
 
3553
        case R_FRV_GOTOFFHI:
3554
        case R_FRV_GOTOFF12:
3555
        case R_FRV_GOTOFFLO:
3556
          relocation -= frvfdpic_got_section (info)->output_section->vma
3557
            + frvfdpic_got_section (info)->output_offset
3558
            + frvfdpic_got_initial_offset (info);
3559
          check_segment[0] = got_segment;
3560
          check_segment[1] = sec
3561
            ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3562
            : (unsigned)-1;
3563
          break;
3564
 
3565
        case R_FRV_FUNCDESC_GOTOFF12:
3566
        case R_FRV_FUNCDESC_GOTOFFHI:
3567
        case R_FRV_FUNCDESC_GOTOFFLO:
3568
          relocation = picrel->fd_entry;
3569
          check_segment[0] = check_segment[1] = got_segment;
3570
          break;
3571
 
3572
        case R_FRV_FUNCDESC:
3573
          {
3574
            int dynindx;
3575
            bfd_vma addend = rel->r_addend;
3576
 
3577
            if (! (h && h->root.type == bfd_link_hash_undefweak
3578
                   && FRVFDPIC_SYM_LOCAL (info, h)))
3579
              {
3580
                /* If the symbol is dynamic and there may be dynamic
3581
                   symbol resolution because we are or are linked with a
3582
                   shared library, emit a FUNCDESC relocation such that
3583
                   the dynamic linker will allocate the function
3584
                   descriptor.  If the symbol needs a non-local function
3585
                   descriptor but binds locally (e.g., its visibility is
3586
                   protected, emit a dynamic relocation decayed to
3587
                   section+offset.  */
3588
                if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h)
3589
                    && FRVFDPIC_SYM_LOCAL (info, h)
3590
                    && !(info->executable && !info->pie))
3591
                  {
3592
                    dynindx = elf_section_data (h->root.u.def.section
3593
                                                ->output_section)->dynindx;
3594
                    addend += h->root.u.def.section->output_offset
3595
                      + h->root.u.def.value;
3596
                  }
3597
                else if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h))
3598
                  {
3599
                    if (addend)
3600
                      {
3601
                        info->callbacks->warning
3602
                          (info, _("R_FRV_FUNCDESC references dynamic symbol with nonzero addend"),
3603
                           name, input_bfd, input_section, rel->r_offset);
3604
                        return FALSE;
3605
                      }
3606
                    dynindx = h->dynindx;
3607
                  }
3608
                else
3609
                  {
3610
                    /* Otherwise, we know we have a private function
3611
                       descriptor, so reference it directly.  */
3612
                    BFD_ASSERT (picrel->privfd);
3613
                    r_type = R_FRV_32;
3614
                    dynindx = elf_section_data (frvfdpic_got_section (info)
3615
                                                ->output_section)->dynindx;
3616
                    addend = frvfdpic_got_section (info)->output_offset
3617
                      + frvfdpic_got_initial_offset (info)
3618
                      + picrel->fd_entry;
3619
                  }
3620
 
3621
                /* If there is room for dynamic symbol resolution, emit
3622
                   the dynamic relocation.  However, if we're linking an
3623
                   executable at a fixed location, we won't have emitted a
3624
                   dynamic symbol entry for the got section, so idx will
3625
                   be zero, which means we can and should compute the
3626
                   address of the private descriptor ourselves.  */
3627
                if (info->executable && !info->pie
3628
                    && (!h || FRVFDPIC_FUNCDESC_LOCAL (info, h)))
3629
                  {
3630
                    addend += frvfdpic_got_section (info)->output_section->vma;
3631
                    if ((bfd_get_section_flags (output_bfd,
3632
                                                input_section->output_section)
3633
                         & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3634
                      {
3635
                        bfd_vma offset;
3636
 
3637
                        if (_frvfdpic_osec_readonly_p (output_bfd,
3638
                                                       input_section
3639
                                                       ->output_section))
3640
                          {
3641
                            info->callbacks->warning
3642
                              (info,
3643
                               _("cannot emit fixups in read-only section"),
3644
                               name, input_bfd, input_section, rel->r_offset);
3645
                            return FALSE;
3646
                          }
3647
 
3648
                        offset = _bfd_elf_section_offset
3649
                          (output_bfd, info,
3650
                           input_section, rel->r_offset);
3651
 
3652
                        if (offset != (bfd_vma)-1)
3653
                          _frvfdpic_add_rofixup (output_bfd,
3654
                                                 frvfdpic_gotfixup_section
3655
                                                 (info),
3656
                                                 offset + input_section
3657
                                                 ->output_section->vma
3658
                                                 + input_section->output_offset,
3659
                                                 picrel);
3660
                      }
3661
                  }
3662
                else if ((bfd_get_section_flags (output_bfd,
3663
                                                 input_section->output_section)
3664
                          & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3665
                  {
3666
                    bfd_vma offset;
3667
 
3668
                    if (_frvfdpic_osec_readonly_p (output_bfd,
3669
                                                   input_section
3670
                                                   ->output_section))
3671
                      {
3672
                        info->callbacks->warning
3673
                          (info,
3674
                           _("cannot emit dynamic relocations in read-only section"),
3675
                           name, input_bfd, input_section, rel->r_offset);
3676
                        return FALSE;
3677
                      }
3678
 
3679
                    offset = _bfd_elf_section_offset
3680
                      (output_bfd, info,
3681
                       input_section, rel->r_offset);
3682
 
3683
                    if (offset != (bfd_vma)-1)
3684
                      _frvfdpic_add_dyn_reloc (output_bfd,
3685
                                               frvfdpic_gotrel_section (info),
3686
                                               offset + input_section
3687
                                               ->output_section->vma
3688
                                               + input_section->output_offset,
3689
                                               r_type, dynindx, addend, picrel);
3690
                  }
3691
                else
3692
                  addend += frvfdpic_got_section (info)->output_section->vma;
3693
              }
3694
 
3695
            /* We want the addend in-place because dynamic
3696
               relocations are REL.  Setting relocation to it should
3697
               arrange for it to be installed.  */
3698
            relocation = addend - rel->r_addend;
3699
          }
3700
          check_segment[0] = check_segment[1] = got_segment;
3701
          break;
3702
 
3703
        case R_FRV_32:
3704
          if (! IS_FDPIC (output_bfd))
3705
            {
3706
              check_segment[0] = check_segment[1] = -1;
3707
              break;
3708
            }
3709
          /* Fall through.  */
3710
        case R_FRV_FUNCDESC_VALUE:
3711
          {
3712
            int dynindx;
3713
            bfd_vma addend = rel->r_addend;
3714
 
3715
            /* If the symbol is dynamic but binds locally, use
3716
               section+offset.  */
3717
            if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
3718
              {
3719
                if (addend && r_type == R_FRV_FUNCDESC_VALUE)
3720
                  {
3721
                    info->callbacks->warning
3722
                      (info, _("R_FRV_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
3723
                       name, input_bfd, input_section, rel->r_offset);
3724
                    return FALSE;
3725
                  }
3726
                dynindx = h->dynindx;
3727
              }
3728
            else
3729
              {
3730
                if (h)
3731
                  addend += h->root.u.def.value;
3732
                else
3733
                  addend += sym->st_value;
3734
                if (osec)
3735
                  addend += osec->output_offset;
3736
                if (osec && osec->output_section
3737
                    && ! bfd_is_abs_section (osec->output_section)
3738
                    && ! bfd_is_und_section (osec->output_section))
3739
                  dynindx = elf_section_data (osec->output_section)->dynindx;
3740
                else
3741
                  dynindx = 0;
3742
              }
3743
 
3744
            /* If we're linking an executable at a fixed address, we
3745
               can omit the dynamic relocation as long as the symbol
3746
               is defined in the current link unit (which is implied
3747
               by its output section not being NULL).  */
3748
            if (info->executable && !info->pie
3749
                && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
3750
              {
3751
                if (osec)
3752
                  addend += osec->output_section->vma;
3753
                if (IS_FDPIC (input_bfd)
3754
                    && (bfd_get_section_flags (output_bfd,
3755
                                               input_section->output_section)
3756
                        & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3757
                  {
3758
                    if (_frvfdpic_osec_readonly_p (output_bfd,
3759
                                                   input_section
3760
                                                   ->output_section))
3761
                      {
3762
                        info->callbacks->warning
3763
                          (info,
3764
                           _("cannot emit fixups in read-only section"),
3765
                           name, input_bfd, input_section, rel->r_offset);
3766
                        return FALSE;
3767
                      }
3768
                    if (!h || h->root.type != bfd_link_hash_undefweak)
3769
                      {
3770
                        bfd_vma offset = _bfd_elf_section_offset
3771
                          (output_bfd, info,
3772
                           input_section, rel->r_offset);
3773
 
3774
                        if (offset != (bfd_vma)-1)
3775
                          {
3776
                            _frvfdpic_add_rofixup (output_bfd,
3777
                                                   frvfdpic_gotfixup_section
3778
                                                   (info),
3779
                                                   offset + input_section
3780
                                                   ->output_section->vma
3781
                                                   + input_section->output_offset,
3782
                                                   picrel);
3783
                            if (r_type == R_FRV_FUNCDESC_VALUE)
3784
                              _frvfdpic_add_rofixup
3785
                                (output_bfd,
3786
                                 frvfdpic_gotfixup_section (info),
3787
                                 offset
3788
                                 + input_section->output_section->vma
3789
                                 + input_section->output_offset + 4, picrel);
3790
                          }
3791
                      }
3792
                  }
3793
              }
3794
            else
3795
              {
3796
                if ((bfd_get_section_flags (output_bfd,
3797
                                            input_section->output_section)
3798
                     & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3799
                  {
3800
                    bfd_vma offset;
3801
 
3802
                    if (_frvfdpic_osec_readonly_p (output_bfd,
3803
                                                   input_section
3804
                                                   ->output_section))
3805
                      {
3806
                        info->callbacks->warning
3807
                          (info,
3808
                           _("cannot emit dynamic relocations in read-only section"),
3809
                           name, input_bfd, input_section, rel->r_offset);
3810
                        return FALSE;
3811
                      }
3812
 
3813
                    offset = _bfd_elf_section_offset
3814
                      (output_bfd, info,
3815
                       input_section, rel->r_offset);
3816
 
3817
                    if (offset != (bfd_vma)-1)
3818
                      _frvfdpic_add_dyn_reloc (output_bfd,
3819
                                               frvfdpic_gotrel_section (info),
3820
                                               offset + input_section
3821
                                               ->output_section->vma
3822
                                               + input_section->output_offset,
3823
                                               r_type, dynindx, addend, picrel);
3824
                  }
3825
                else if (osec)
3826
                  addend += osec->output_section->vma;
3827
                /* We want the addend in-place because dynamic
3828
                   relocations are REL.  Setting relocation to it
3829
                   should arrange for it to be installed.  */
3830
                relocation = addend - rel->r_addend;
3831
              }
3832
 
3833
            if (r_type == R_FRV_FUNCDESC_VALUE)
3834
              {
3835
                /* If we've omitted the dynamic relocation, just emit
3836
                   the fixed addresses of the symbol and of the local
3837
                   GOT base offset.  */
3838
                if (info->executable && !info->pie
3839
                    && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
3840
                  bfd_put_32 (output_bfd,
3841
                              frvfdpic_got_section (info)->output_section->vma
3842
                              + frvfdpic_got_section (info)->output_offset
3843
                              + frvfdpic_got_initial_offset (info),
3844
                              contents + rel->r_offset + 4);
3845
                else
3846
                  /* A function descriptor used for lazy or local
3847
                     resolving is initialized such that its high word
3848
                     contains the output section index in which the
3849
                     PLT entries are located, and the low word
3850
                     contains the offset of the lazy PLT entry entry
3851
                     point into that section.  */
3852
                  bfd_put_32 (output_bfd,
3853
                              h && ! FRVFDPIC_SYM_LOCAL (info, h)
3854
                              ? 0
3855
                              : _frvfdpic_osec_to_segment (output_bfd,
3856
                                                           sec
3857
                                                           ->output_section),
3858
                              contents + rel->r_offset + 4);
3859
              }
3860
          }
3861
          check_segment[0] = check_segment[1] = got_segment;
3862
          break;
3863
 
3864
        case R_FRV_GPREL12:
3865
        case R_FRV_GPRELU12:
3866
        case R_FRV_GPREL32:
3867
        case R_FRV_GPRELHI:
3868
        case R_FRV_GPRELLO:
3869
          check_segment[0] = gprel_segment;
3870
          check_segment[1] = sec
3871
            ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3872
            : (unsigned)-1;
3873
          break;
3874
 
3875
        case R_FRV_GETTLSOFF:
3876
          relocation = frvfdpic_plt_section (info)->output_section->vma
3877
            + frvfdpic_plt_section (info)->output_offset
3878
            + picrel->tlsplt_entry;
3879
          BFD_ASSERT (picrel->tlsplt_entry != (bfd_vma)-1
3880
                      && picrel->tlsdesc_entry);
3881
          check_segment[0] = isec_segment;
3882
          check_segment[1] = plt_segment;
3883
          break;
3884
 
3885
        case R_FRV_GOTTLSDESC12:
3886
        case R_FRV_GOTTLSDESCHI:
3887
        case R_FRV_GOTTLSDESCLO:
3888
          BFD_ASSERT (picrel->tlsdesc_entry);
3889
          relocation = picrel->tlsdesc_entry;
3890
          check_segment[0] = tls_segment;
3891
          check_segment[1] = sec
3892
            && ! bfd_is_abs_section (sec)
3893
            && ! bfd_is_und_section (sec)
3894
            ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3895
            : tls_segment;
3896
          break;
3897
 
3898
        case R_FRV_TLSMOFF12:
3899
        case R_FRV_TLSMOFFHI:
3900
        case R_FRV_TLSMOFFLO:
3901
        case R_FRV_TLSMOFF:
3902
          check_segment[0] = tls_segment;
3903
          if (! sec)
3904
            check_segment[1] = -1;
3905
          else if (bfd_is_abs_section (sec)
3906
                   || bfd_is_und_section (sec))
3907
            {
3908
              relocation = 0;
3909
              check_segment[1] = tls_segment;
3910
            }
3911
          else if (sec->output_section)
3912
            {
3913
              relocation -= tls_biased_base (info);
3914
              check_segment[1] =
3915
                _frvfdpic_osec_to_segment (output_bfd, sec->output_section);
3916
            }
3917
          else
3918
            check_segment[1] = -1;
3919
          break;
3920
 
3921
        case R_FRV_GOTTLSOFF12:
3922
        case R_FRV_GOTTLSOFFHI:
3923
        case R_FRV_GOTTLSOFFLO:
3924
          BFD_ASSERT (picrel->tlsoff_entry);
3925
          relocation = picrel->tlsoff_entry;
3926
          check_segment[0] = tls_segment;
3927
          check_segment[1] = sec
3928
            && ! bfd_is_abs_section (sec)
3929
            && ! bfd_is_und_section (sec)
3930
            ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3931
            : tls_segment;
3932
          break;
3933
 
3934
        case R_FRV_TLSDESC_VALUE:
3935
        case R_FRV_TLSOFF:
3936
          /* These shouldn't be present in input object files.  */
3937
          check_segment[0] = check_segment[1] = isec_segment;
3938
          break;
3939
 
3940
        case R_FRV_TLSDESC_RELAX:
3941
        case R_FRV_GETTLSOFF_RELAX:
3942
        case R_FRV_TLSOFF_RELAX:
3943
          /* These are just annotations for relaxation, nothing to do
3944
             here.  */
3945
          continue;
3946
 
3947
        default:
3948
          check_segment[0] = isec_segment;
3949
          check_segment[1] = sec
3950
            ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3951
            : (unsigned)-1;
3952
          break;
3953
        }
3954
 
3955
      if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd))
3956
        {
3957
          /* If you take this out, remove the #error from fdpic-static-6.d
3958
             in the ld testsuite.  */
3959
          /* This helps catch problems in GCC while we can't do more
3960
             than static linking.  The idea is to test whether the
3961
             input file basename is crt0.o only once.  */
3962
          if (silence_segment_error == 1)
3963
            silence_segment_error =
3964
              (strlen (input_bfd->filename) == 6
3965
               && strcmp (input_bfd->filename, "crt0.o") == 0)
3966
              || (strlen (input_bfd->filename) > 6
3967
                  && strcmp (input_bfd->filename
3968
                             + strlen (input_bfd->filename) - 7,
3969
                             "/crt0.o") == 0)
3970
              ? -1 : 0;
3971
          if (!silence_segment_error
3972
              /* We don't want duplicate errors for undefined
3973
                 symbols.  */
3974
              && !(picrel && picrel->symndx == -1
3975
                   && picrel->d.h->root.type == bfd_link_hash_undefined))
3976
            {
3977
              if (info->shared || info->pie)
3978
                (*_bfd_error_handler)
3979
                  (_("%B(%A+0x%lx): reloc against `%s': %s"),
3980
                   input_bfd, input_section, (long)rel->r_offset, name,
3981
                   _("relocation references a different segment"));
3982
              else
3983
                info->callbacks->warning
3984
                  (info,
3985
                   _("relocation references a different segment"),
3986
                   name, input_bfd, input_section, rel->r_offset);
3987
            }
3988
          if (!silence_segment_error && (info->shared || info->pie))
3989
            return FALSE;
3990
          elf_elfheader (output_bfd)->e_flags |= EF_FRV_PIC;
3991
        }
3992
 
3993
      switch (r_type)
3994
        {
3995
        case R_FRV_GOTOFFHI:
3996
        case R_FRV_TLSMOFFHI:
3997
          /* We need the addend to be applied before we shift the
3998
             value right.  */
3999
          relocation += rel->r_addend;
4000
          /* Fall through.  */
4001
        case R_FRV_GOTHI:
4002
        case R_FRV_FUNCDESC_GOTHI:
4003
        case R_FRV_FUNCDESC_GOTOFFHI:
4004
        case R_FRV_GOTTLSOFFHI:
4005
        case R_FRV_GOTTLSDESCHI:
4006
          relocation >>= 16;
4007
          /* Fall through.  */
4008
 
4009
        case R_FRV_GOTLO:
4010
        case R_FRV_FUNCDESC_GOTLO:
4011
        case R_FRV_GOTOFFLO:
4012
        case R_FRV_FUNCDESC_GOTOFFLO:
4013
        case R_FRV_GOTTLSOFFLO:
4014
        case R_FRV_GOTTLSDESCLO:
4015
        case R_FRV_TLSMOFFLO:
4016
          relocation &= 0xffff;
4017
          break;
4018
 
4019
        default:
4020
          break;
4021
        }
4022
 
4023
      switch (r_type)
4024
        {
4025
        case R_FRV_LABEL24:
4026
          if (! IS_FDPIC (output_bfd) || ! picrel->plt)
4027
            break;
4028
          /* Fall through.  */
4029
 
4030
          /* When referencing a GOT entry, a function descriptor or a
4031
             PLT, we don't want the addend to apply to the reference,
4032
             but rather to the referenced symbol.  The actual entry
4033
             will have already been created taking the addend into
4034
             account, so cancel it out here.  */
4035
        case R_FRV_GOT12:
4036
        case R_FRV_GOTHI:
4037
        case R_FRV_GOTLO:
4038
        case R_FRV_FUNCDESC_GOT12:
4039
        case R_FRV_FUNCDESC_GOTHI:
4040
        case R_FRV_FUNCDESC_GOTLO:
4041
        case R_FRV_FUNCDESC_GOTOFF12:
4042
        case R_FRV_FUNCDESC_GOTOFFHI:
4043
        case R_FRV_FUNCDESC_GOTOFFLO:
4044
        case R_FRV_GETTLSOFF:
4045
        case R_FRV_GOTTLSDESC12:
4046
        case R_FRV_GOTTLSDESCHI:
4047
        case R_FRV_GOTTLSDESCLO:
4048
        case R_FRV_GOTTLSOFF12:
4049
        case R_FRV_GOTTLSOFFHI:
4050
        case R_FRV_GOTTLSOFFLO:
4051
          /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF12
4052
             here, since we do want to apply the addend to the others.
4053
             Note that we've applied the addend to GOTOFFHI before we
4054
             shifted it right.  */
4055
        case R_FRV_GOTOFFHI:
4056
        case R_FRV_TLSMOFFHI:
4057
          relocation -= rel->r_addend;
4058
          break;
4059
 
4060
        default:
4061
          break;
4062
        }
4063
 
4064
     if (r_type == R_FRV_HI16)
4065
       r = elf32_frv_relocate_hi16 (input_bfd, rel, contents, relocation);
4066
 
4067
     else if (r_type == R_FRV_LO16)
4068
       r = elf32_frv_relocate_lo16 (input_bfd, rel, contents, relocation);
4069
 
4070
     else if (r_type == R_FRV_LABEL24 || r_type == R_FRV_GETTLSOFF)
4071
       r = elf32_frv_relocate_label24 (input_bfd, input_section, rel,
4072
                                       contents, relocation);
4073
 
4074
     else if (r_type == R_FRV_GPREL12)
4075
       r = elf32_frv_relocate_gprel12 (info, input_bfd, input_section, rel,
4076
                                       contents, relocation);
4077
 
4078
     else if (r_type == R_FRV_GPRELU12)
4079
       r = elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, rel,
4080
                                        contents, relocation);
4081
 
4082
     else if (r_type == R_FRV_GPRELLO)
4083
       r = elf32_frv_relocate_gprello (info, input_bfd, input_section, rel,
4084
                                       contents, relocation);
4085
 
4086
     else if (r_type == R_FRV_GPRELHI)
4087
       r = elf32_frv_relocate_gprelhi (info, input_bfd, input_section, rel,
4088
                                       contents, relocation);
4089
 
4090
     else if (r_type == R_FRV_TLSOFF
4091
              || r_type == R_FRV_TLSDESC_VALUE)
4092
       r = bfd_reloc_notsupported;
4093
 
4094
     else
4095
       r = frv_final_link_relocate (howto, input_bfd, input_section, contents,
4096
                                    rel, relocation);
4097
 
4098
      if (r != bfd_reloc_ok)
4099
        {
4100
          const char * msg = (const char *) NULL;
4101
 
4102
          switch (r)
4103
            {
4104
            case bfd_reloc_overflow:
4105
              r = info->callbacks->reloc_overflow
4106
                (info, (h ? &h->root : NULL), name, howto->name,
4107
                 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4108
              break;
4109
 
4110
            case bfd_reloc_undefined:
4111
              r = info->callbacks->undefined_symbol
4112
                (info, name, input_bfd, input_section, rel->r_offset, TRUE);
4113
              break;
4114
 
4115
            case bfd_reloc_outofrange:
4116
              msg = _("internal error: out of range error");
4117
              break;
4118
 
4119
            case bfd_reloc_notsupported:
4120
              msg = _("internal error: unsupported relocation error");
4121
              break;
4122
 
4123
            case bfd_reloc_dangerous:
4124
              msg = _("internal error: dangerous relocation");
4125
              break;
4126
 
4127
            default:
4128
              msg = _("internal error: unknown error");
4129
              break;
4130
            }
4131
 
4132
          if (msg)
4133
            {
4134
              (*_bfd_error_handler)
4135
                (_("%B(%A+0x%lx): reloc against `%s': %s"),
4136
                 input_bfd, input_section, (long)rel->r_offset, name, msg);
4137
              return FALSE;
4138
            }
4139
 
4140
          if (! r)
4141
            return FALSE;
4142
        }
4143
    }
4144
 
4145
  return TRUE;
4146
}
4147
 
4148
/* Return the section that should be marked against GC for a given
4149
   relocation.  */
4150
 
4151
static asection *
4152
elf32_frv_gc_mark_hook (asection *sec,
4153
                        struct bfd_link_info *info,
4154
                        Elf_Internal_Rela *rel,
4155
                        struct elf_link_hash_entry *h,
4156
                        Elf_Internal_Sym *sym)
4157
{
4158
  if (h != NULL)
4159
    switch (ELF32_R_TYPE (rel->r_info))
4160
      {
4161
      case R_FRV_GNU_VTINHERIT:
4162
      case R_FRV_GNU_VTENTRY:
4163
        return NULL;
4164
      }
4165
 
4166
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4167
}
4168
 
4169
/* Hook called by the linker routine which adds symbols from an object
4170
   file.  We use it to put .comm items in .scomm, and not .comm.  */
4171
 
4172
static bfd_boolean
4173
elf32_frv_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
4174
     bfd *abfd;
4175
     struct bfd_link_info *info;
4176
     Elf_Internal_Sym *sym;
4177
     const char **namep ATTRIBUTE_UNUSED;
4178
     flagword *flagsp ATTRIBUTE_UNUSED;
4179
     asection **secp;
4180
     bfd_vma *valp;
4181
{
4182
  if (sym->st_shndx == SHN_COMMON
4183
      && !info->relocatable
4184
      && (int)sym->st_size <= (int)bfd_get_gp_size (abfd))
4185
    {
4186
      /* Common symbols less than or equal to -G nn bytes are
4187
         automatically put into .sbss.  */
4188
 
4189
      asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
4190
 
4191
      if (scomm == NULL)
4192
        {
4193
          scomm = bfd_make_section_with_flags (abfd, ".scommon",
4194
                                               (SEC_ALLOC
4195
                                                | SEC_IS_COMMON
4196
                                                | SEC_LINKER_CREATED));
4197
          if (scomm == NULL)
4198
            return FALSE;
4199
        }
4200
 
4201
      *secp = scomm;
4202
      *valp = sym->st_size;
4203
    }
4204
 
4205
  return TRUE;
4206
}
4207
 
4208
/* We need dynamic symbols for every section, since segments can
4209
   relocate independently.  */
4210
static bfd_boolean
4211
_frvfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
4212
                                    struct bfd_link_info *info
4213
                                    ATTRIBUTE_UNUSED,
4214
                                    asection *p ATTRIBUTE_UNUSED)
4215
{
4216
  switch (elf_section_data (p)->this_hdr.sh_type)
4217
    {
4218
    case SHT_PROGBITS:
4219
    case SHT_NOBITS:
4220
      /* If sh_type is yet undecided, assume it could be
4221
         SHT_PROGBITS/SHT_NOBITS.  */
4222
    case SHT_NULL:
4223
      return FALSE;
4224
 
4225
      /* There shouldn't be section relative relocations
4226
         against any other section.  */
4227
    default:
4228
      return TRUE;
4229
    }
4230
}
4231
 
4232
/* Create  a .got section, as well as its additional info field.  This
4233
   is almost entirely copied from
4234
   elflink.c:_bfd_elf_create_got_section().  */
4235
 
4236
static bfd_boolean
4237
_frv_create_got_section (bfd *abfd, struct bfd_link_info *info)
4238
{
4239
  flagword flags, pltflags;
4240
  asection *s;
4241
  struct elf_link_hash_entry *h;
4242
  struct bfd_link_hash_entry *bh;
4243
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4244
  int ptralign;
4245
  int offset;
4246
 
4247
  /* This function may be called more than once.  */
4248
  s = bfd_get_section_by_name (abfd, ".got");
4249
  if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
4250
    return TRUE;
4251
 
4252
  /* Machine specific: although pointers are 32-bits wide, we want the
4253
     GOT to be aligned to a 64-bit boundary, such that function
4254
     descriptors in it can be accessed with 64-bit loads and
4255
     stores.  */
4256
  ptralign = 3;
4257
 
4258
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4259
           | SEC_LINKER_CREATED);
4260
  pltflags = flags;
4261
 
4262
  s = bfd_make_section_with_flags (abfd, ".got", flags);
4263
  if (s == NULL
4264
      || !bfd_set_section_alignment (abfd, s, ptralign))
4265
    return FALSE;
4266
 
4267
  if (bed->want_got_plt)
4268
    {
4269
      s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
4270
      if (s == NULL
4271
          || !bfd_set_section_alignment (abfd, s, ptralign))
4272
        return FALSE;
4273
    }
4274
 
4275
  if (bed->want_got_sym)
4276
    {
4277
      /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
4278
         (or .got.plt) section.  We don't do this in the linker script
4279
         because we don't want to define the symbol if we are not creating
4280
         a global offset table.  */
4281
      h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
4282
      elf_hash_table (info)->hgot = h;
4283
      if (h == NULL)
4284
        return FALSE;
4285
 
4286
      /* Machine-specific: we want the symbol for executables as
4287
         well.  */
4288
      if (! bfd_elf_link_record_dynamic_symbol (info, h))
4289
        return FALSE;
4290
    }
4291
 
4292
  /* The first bit of the global offset table is the header.  */
4293
  s->size += bed->got_header_size;
4294
 
4295
  /* This is the machine-specific part.  Create and initialize section
4296
     data for the got.  */
4297
  if (IS_FDPIC (abfd))
4298
    {
4299
      frvfdpic_got_section (info) = s;
4300
      frvfdpic_relocs_info (info) = htab_try_create (1,
4301
                                                     frvfdpic_relocs_info_hash,
4302
                                                     frvfdpic_relocs_info_eq,
4303
                                                     (htab_del) NULL);
4304
      if (! frvfdpic_relocs_info (info))
4305
        return FALSE;
4306
 
4307
      s = bfd_make_section_with_flags (abfd, ".rel.got",
4308
                                       (flags | SEC_READONLY));
4309
      if (s == NULL
4310
          || ! bfd_set_section_alignment (abfd, s, 2))
4311
        return FALSE;
4312
 
4313
      frvfdpic_gotrel_section (info) = s;
4314
 
4315
      /* Machine-specific.  */
4316
      s = bfd_make_section_with_flags (abfd, ".rofixup",
4317
                                       (flags | SEC_READONLY));
4318
      if (s == NULL
4319
          || ! bfd_set_section_alignment (abfd, s, 2))
4320
        return FALSE;
4321
 
4322
      frvfdpic_gotfixup_section (info) = s;
4323
      offset = -2048;
4324
      flags = BSF_GLOBAL;
4325
    }
4326
  else
4327
    {
4328
      offset = 2048;
4329
      flags = BSF_GLOBAL | BSF_WEAK;
4330
    }
4331
 
4332
  /* Define _gp in .rofixup, for FDPIC, or .got otherwise.  If it
4333
     turns out that we're linking with a different linker script, the
4334
     linker script will override it.  */
4335
  bh = NULL;
4336
  if (!(_bfd_generic_link_add_one_symbol
4337
        (info, abfd, "_gp", flags, s, offset, (const char *) NULL, FALSE,
4338
         bed->collect, &bh)))
4339
    return FALSE;
4340
  h = (struct elf_link_hash_entry *) bh;
4341
  h->def_regular = 1;
4342
  h->type = STT_OBJECT;
4343
  /* h->other = STV_HIDDEN; */ /* Should we?  */
4344
 
4345
  /* Machine-specific: we want the symbol for executables as well.  */
4346
  if (IS_FDPIC (abfd) && ! bfd_elf_link_record_dynamic_symbol (info, h))
4347
    return FALSE;
4348
 
4349
  if (!IS_FDPIC (abfd))
4350
    return TRUE;
4351
 
4352
  /* FDPIC supports Thread Local Storage, and this may require a
4353
     procedure linkage table for TLS PLT entries.  */
4354
 
4355
  /* This is mostly copied from
4356
     elflink.c:_bfd_elf_create_dynamic_sections().  */
4357
 
4358
  flags = pltflags;
4359
  pltflags |= SEC_CODE;
4360
  if (bed->plt_not_loaded)
4361
    pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
4362
  if (bed->plt_readonly)
4363
    pltflags |= SEC_READONLY;
4364
 
4365
  s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
4366
  if (s == NULL
4367
      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
4368
    return FALSE;
4369
  /* FRV-specific: remember it.  */
4370
  frvfdpic_plt_section (info) = s;
4371
 
4372
  /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
4373
     .plt section.  */
4374
  if (bed->want_plt_sym)
4375
    {
4376
      h = _bfd_elf_define_linkage_sym (abfd, info, s,
4377
                                       "_PROCEDURE_LINKAGE_TABLE_");
4378
      elf_hash_table (info)->hplt = h;
4379
      if (h == NULL)
4380
        return FALSE;
4381
    }
4382
 
4383
  /* FRV-specific: we want rel relocations for the plt.  */
4384
  s = bfd_make_section_with_flags (abfd, ".rel.plt",
4385
                                   flags | SEC_READONLY);
4386
  if (s == NULL
4387
      || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
4388
    return FALSE;
4389
  /* FRV-specific: remember it.  */
4390
  frvfdpic_pltrel_section (info) = s;
4391
 
4392
  return TRUE;
4393
}
4394
 
4395
/* Make sure the got and plt sections exist, and that our pointers in
4396
   the link hash table point to them.  */
4397
 
4398
static bfd_boolean
4399
elf32_frvfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4400
{
4401
  /* This is mostly copied from
4402
     elflink.c:_bfd_elf_create_dynamic_sections().  */
4403
  flagword flags;
4404
  asection *s;
4405
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4406
 
4407
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4408
           | SEC_LINKER_CREATED);
4409
 
4410
  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4411
     .rel[a].bss sections.  */
4412
 
4413
  /* FRV-specific: we want to create the GOT and the PLT in the FRV
4414
     way.  */
4415
  if (! _frv_create_got_section (abfd, info))
4416
    return FALSE;
4417
 
4418
  /* FRV-specific: make sure we created everything we wanted.  */
4419
  BFD_ASSERT (frvfdpic_got_section (info) && frvfdpic_gotrel_section (info)
4420
              && frvfdpic_gotfixup_section (info)
4421
              && frvfdpic_plt_section (info)
4422
              && frvfdpic_pltrel_section (info));
4423
 
4424
  if (bed->want_dynbss)
4425
    {
4426
      /* The .dynbss section is a place to put symbols which are defined
4427
         by dynamic objects, are referenced by regular objects, and are
4428
         not functions.  We must allocate space for them in the process
4429
         image and use a R_*_COPY reloc to tell the dynamic linker to
4430
         initialize them at run time.  The linker script puts the .dynbss
4431
         section into the .bss section of the final image.  */
4432
      s = bfd_make_section_with_flags (abfd, ".dynbss",
4433
                                       SEC_ALLOC | SEC_LINKER_CREATED);
4434
      if (s == NULL)
4435
        return FALSE;
4436
 
4437
      /* The .rel[a].bss section holds copy relocs.  This section is not
4438
     normally needed.  We need to create it here, though, so that the
4439
     linker will map it to an output section.  We can't just create it
4440
     only if we need it, because we will not know whether we need it
4441
     until we have seen all the input files, and the first time the
4442
     main linker code calls BFD after examining all the input files
4443
     (size_dynamic_sections) the input sections have already been
4444
     mapped to the output sections.  If the section turns out not to
4445
     be needed, we can discard it later.  We will never need this
4446
     section when generating a shared object, since they do not use
4447
     copy relocs.  */
4448
      if (! info->shared)
4449
        {
4450
          s = bfd_make_section_with_flags (abfd,
4451
                                           (bed->default_use_rela_p
4452
                                            ? ".rela.bss" : ".rel.bss"),
4453
                                           flags | SEC_READONLY);
4454
          if (s == NULL
4455
              || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
4456
            return FALSE;
4457
        }
4458
    }
4459
 
4460
  return TRUE;
4461
}
4462
 
4463
/* Compute the total GOT and PLT size required by each symbol in each
4464
   range.  Symbols may require up to 4 words in the GOT: an entry
4465
   pointing to the symbol, an entry pointing to its function
4466
   descriptor, and a private function descriptors taking two
4467
   words.  */
4468
 
4469
static void
4470
_frvfdpic_count_nontls_entries (struct frvfdpic_relocs_info *entry,
4471
                                struct _frvfdpic_dynamic_got_info *dinfo)
4472
{
4473
  /* Allocate space for a GOT entry pointing to the symbol.  */
4474
  if (entry->got12)
4475
    dinfo->got12 += 4;
4476
  else if (entry->gotlos)
4477
    dinfo->gotlos += 4;
4478
  else if (entry->gothilo)
4479
    dinfo->gothilo += 4;
4480
  else
4481
    entry->relocs32--;
4482
  entry->relocs32++;
4483
 
4484
  /* Allocate space for a GOT entry pointing to the function
4485
     descriptor.  */
4486
  if (entry->fdgot12)
4487
    dinfo->got12 += 4;
4488
  else if (entry->fdgotlos)
4489
    dinfo->gotlos += 4;
4490
  else if (entry->fdgothilo)
4491
    dinfo->gothilo += 4;
4492
  else
4493
    entry->relocsfd--;
4494
  entry->relocsfd++;
4495
 
4496
  /* Decide whether we need a PLT entry, a function descriptor in the
4497
     GOT, and a lazy PLT entry for this symbol.  */
4498
  entry->plt = entry->call
4499
    && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4500
    && elf_hash_table (dinfo->info)->dynamic_sections_created;
4501
  entry->privfd = entry->plt
4502
    || entry->fdgoff12 || entry->fdgofflos || entry->fdgoffhilo
4503
    || ((entry->fd || entry->fdgot12 || entry->fdgotlos || entry->fdgothilo)
4504
        && (entry->symndx != -1
4505
            || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
4506
  entry->lazyplt = entry->privfd
4507
    && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4508
    && ! (dinfo->info->flags & DF_BIND_NOW)
4509
    && elf_hash_table (dinfo->info)->dynamic_sections_created;
4510
 
4511
  /* Allocate space for a function descriptor.  */
4512
  if (entry->fdgoff12)
4513
    dinfo->fd12 += 8;
4514
  else if (entry->fdgofflos)
4515
    dinfo->fdlos += 8;
4516
  else if (entry->privfd && entry->plt)
4517
    dinfo->fdplt += 8;
4518
  else if (entry->privfd)
4519
    dinfo->fdhilo += 8;
4520
  else
4521
    entry->relocsfdv--;
4522
  entry->relocsfdv++;
4523
 
4524
  if (entry->lazyplt)
4525
    dinfo->lzplt += 8;
4526
}
4527
 
4528
/* Compute the total GOT size required by each TLS symbol in each
4529
   range.  Symbols may require up to 5 words in the GOT: an entry
4530
   holding the TLS offset for the symbol, and an entry with a full TLS
4531
   descriptor taking 4 words.  */
4532
 
4533
static void
4534
_frvfdpic_count_tls_entries (struct frvfdpic_relocs_info *entry,
4535
                             struct _frvfdpic_dynamic_got_info *dinfo,
4536
                             bfd_boolean subtract)
4537
{
4538
  const int l = subtract ? -1 : 1;
4539
 
4540
  /* Allocate space for a GOT entry with the TLS offset of the
4541
     symbol.  */
4542
  if (entry->tlsoff12)
4543
    dinfo->got12 += 4 * l;
4544
  else if (entry->tlsofflos)
4545
    dinfo->gotlos += 4 * l;
4546
  else if (entry->tlsoffhilo)
4547
    dinfo->gothilo += 4 * l;
4548
  else
4549
    entry->relocstlsoff -= l;
4550
  entry->relocstlsoff += l;
4551
 
4552
  /* If there's any TLSOFF relocation, mark the output file as not
4553
     suitable for dlopening.  This mark will remain even if we relax
4554
     all such relocations, but this is not a problem, since we'll only
4555
     do so for executables, and we definitely don't want anyone
4556
     dlopening executables.  */
4557
  if (entry->relocstlsoff)
4558
    dinfo->info->flags |= DF_STATIC_TLS;
4559
 
4560
  /* Allocate space for a TLS descriptor.  */
4561
  if (entry->tlsdesc12)
4562
    dinfo->tlsd12 += 8 * l;
4563
  else if (entry->tlsdesclos)
4564
    dinfo->tlsdlos += 8 * l;
4565
  else if (entry->tlsplt)
4566
    dinfo->tlsdplt += 8 * l;
4567
  else if (entry->tlsdeschilo)
4568
    dinfo->tlsdhilo += 8 * l;
4569
  else
4570
    entry->relocstlsd -= l;
4571
  entry->relocstlsd += l;
4572
}
4573
 
4574
/* Compute the number of dynamic relocations and fixups that a symbol
4575
   requires, and add (or subtract) from the grand and per-symbol
4576
   totals.  */
4577
 
4578
static void
4579
_frvfdpic_count_relocs_fixups (struct frvfdpic_relocs_info *entry,
4580
                               struct _frvfdpic_dynamic_got_info *dinfo,
4581
                               bfd_boolean subtract)
4582
{
4583
  bfd_vma relocs = 0, fixups = 0, tlsrets = 0;
4584
 
4585
  if (!dinfo->info->executable || dinfo->info->pie)
4586
    {
4587
      relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv
4588
        + entry->relocstlsd;
4589
 
4590
      /* In the executable, TLS relocations to symbols that bind
4591
         locally (including those that resolve to global TLS offsets)
4592
         are resolved immediately, without any need for fixups or
4593
         dynamic relocations.  In shared libraries, however, we must
4594
         emit dynamic relocations even for local symbols, because we
4595
         don't know the module id the library is going to get at
4596
         run-time, nor its TLS base offset.  */
4597
      if (!dinfo->info->executable
4598
          || (entry->symndx == -1
4599
              && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4600
        relocs += entry->relocstlsoff;
4601
    }
4602
  else
4603
    {
4604
      if (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
4605
        {
4606
          if (entry->symndx != -1
4607
              || entry->d.h->root.type != bfd_link_hash_undefweak)
4608
            fixups += entry->relocs32 + 2 * entry->relocsfdv;
4609
          fixups += entry->relocstlsd;
4610
          tlsrets += entry->relocstlsd;
4611
        }
4612
      else
4613
        {
4614
          relocs += entry->relocs32 + entry->relocsfdv
4615
            + entry->relocstlsoff + entry->relocstlsd;
4616
        }
4617
 
4618
      if (entry->symndx != -1
4619
          || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
4620
        {
4621
          if (entry->symndx != -1
4622
              || entry->d.h->root.type != bfd_link_hash_undefweak)
4623
            fixups += entry->relocsfd;
4624
        }
4625
      else
4626
        relocs += entry->relocsfd;
4627
    }
4628
 
4629
  if (subtract)
4630
    {
4631
      relocs = - relocs;
4632
      fixups = - fixups;
4633
      tlsrets = - tlsrets;
4634
    }
4635
 
4636
  entry->dynrelocs += relocs;
4637
  entry->fixups += fixups;
4638
  dinfo->relocs += relocs;
4639
  dinfo->fixups += fixups;
4640
  dinfo->tls_ret_refs += tlsrets;
4641
}
4642
 
4643
/* Look for opportunities to relax TLS relocations.  We can assume
4644
   we're linking the main executable or a static-tls library, since
4645
   otherwise we wouldn't have got here.  When relaxing, we have to
4646
   first undo any previous accounting of TLS uses of fixups, dynamic
4647
   relocations, GOT and PLT entries.  */
4648
 
4649
static void
4650
_frvfdpic_relax_tls_entries (struct frvfdpic_relocs_info *entry,
4651
                             struct _frvfdpic_dynamic_got_info *dinfo,
4652
                             bfd_boolean relaxing)
4653
{
4654
  bfd_boolean changed = ! relaxing;
4655
 
4656
  BFD_ASSERT (dinfo->info->executable
4657
              || (dinfo->info->flags & DF_STATIC_TLS));
4658
 
4659
  if (entry->tlsdesc12 || entry->tlsdesclos || entry->tlsdeschilo)
4660
    {
4661
      if (! changed)
4662
        {
4663
          _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4664
          _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4665
          changed = TRUE;
4666
        }
4667
 
4668
      /* When linking an executable, we can always decay GOTTLSDESC to
4669
         TLSMOFF, if the symbol is local, or GOTTLSOFF, otherwise.
4670
         When linking a static-tls shared library, using TLSMOFF is
4671
         not an option, but we can still use GOTTLSOFF.  When decaying
4672
         to GOTTLSOFF, we must keep the GOT entry in range.  We know
4673
         it has to fit because we'll be trading the 4 words of hte TLS
4674
         descriptor for a single word in the same range.  */
4675
      if (! dinfo->info->executable
4676
          || (entry->symndx == -1
4677
              && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4678
        {
4679
          entry->tlsoff12 |= entry->tlsdesc12;
4680
          entry->tlsofflos |= entry->tlsdesclos;
4681
          entry->tlsoffhilo |= entry->tlsdeschilo;
4682
        }
4683
 
4684
      entry->tlsdesc12 = entry->tlsdesclos = entry->tlsdeschilo = 0;
4685
    }
4686
 
4687
  /* We can only decay TLSOFFs or call #gettlsoff to TLSMOFF in the
4688
     main executable.  We have to check whether the symbol's TLSOFF is
4689
     in range for a setlos.  For symbols with a hash entry, we can
4690
     determine exactly what to do; for others locals, we don't have
4691
     addresses handy, so we use the size of the TLS section as an
4692
     approximation.  If we get it wrong, we'll retain a GOT entry
4693
     holding the TLS offset (without dynamic relocations or fixups),
4694
     but we'll still optimize away the loads from it.  Since TLS sizes
4695
     are generally very small, it's probably not worth attempting to
4696
     do better than this.  */
4697
  if ((entry->tlsplt
4698
       || entry->tlsoff12 || entry->tlsofflos || entry->tlsoffhilo)
4699
      && dinfo->info->executable && relaxing
4700
      && ((entry->symndx == -1
4701
           && FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4702
           /* The above may hold for an undefweak TLS symbol, so make
4703
              sure we don't have this case before accessing def.value
4704
              and def.section.  */
4705
           && (entry->d.h->root.type == bfd_link_hash_undefweak
4706
               || (bfd_vma)(entry->d.h->root.u.def.value
4707
                            + (entry->d.h->root.u.def.section
4708
                               ->output_section->vma)
4709
                            + entry->d.h->root.u.def.section->output_offset
4710
                            + entry->addend
4711
                            - tls_biased_base (dinfo->info)
4712
                            + 32768) < (bfd_vma)65536))
4713
          || (entry->symndx != -1
4714
              && (elf_hash_table (dinfo->info)->tls_sec->size
4715
                  + abs (entry->addend) < 32768 + FRVFDPIC_TLS_BIAS))))
4716
    {
4717
      if (! changed)
4718
        {
4719
          _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4720
          _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4721
          changed = TRUE;
4722
        }
4723
 
4724
      entry->tlsplt =
4725
        entry->tlsoff12 = entry->tlsofflos = entry->tlsoffhilo = 0;
4726
    }
4727
 
4728
  /* We can decay `call #gettlsoff' to a ldi #tlsoff if we already
4729
     have a #gottlsoff12 relocation for this entry, or if we can fit
4730
     one more in the 12-bit (and 16-bit) ranges.  */
4731
  if (entry->tlsplt
4732
      && (entry->tlsoff12
4733
          || (relaxing
4734
              && dinfo->got12 + dinfo->fd12 + dinfo->tlsd12 <= 4096 - 12 - 4
4735
              && (dinfo->got12 + dinfo->fd12 + dinfo->tlsd12
4736
                  + dinfo->gotlos + dinfo->fdlos + dinfo->tlsdlos
4737
                  <= 65536 - 12 - 4))))
4738
    {
4739
      if (! changed)
4740
        {
4741
          _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4742
          _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4743
          changed = TRUE;
4744
        }
4745
 
4746
      entry->tlsoff12 = 1;
4747
      entry->tlsplt = 0;
4748
    }
4749
 
4750
  if (changed)
4751
    {
4752
      _frvfdpic_count_tls_entries (entry, dinfo, FALSE);
4753
      _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE);
4754
    }
4755
 
4756
  return;
4757
}
4758
 
4759
/* Compute the total GOT and PLT size required by each symbol in each range. *
4760
   Symbols may require up to 4 words in the GOT: an entry pointing to
4761
   the symbol, an entry pointing to its function descriptor, and a
4762
   private function descriptors taking two words.  */
4763
 
4764
static int
4765
_frvfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
4766
{
4767
  struct frvfdpic_relocs_info *entry = *entryp;
4768
  struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
4769
 
4770
  _frvfdpic_count_nontls_entries (entry, dinfo);
4771
 
4772
  if (dinfo->info->executable || (dinfo->info->flags & DF_STATIC_TLS))
4773
    _frvfdpic_relax_tls_entries (entry, dinfo, FALSE);
4774
  else
4775
    {
4776
      _frvfdpic_count_tls_entries (entry, dinfo, FALSE);
4777
      _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE);
4778
    }
4779
 
4780
  return 1;
4781
}
4782
 
4783
/* Determine the positive and negative ranges to be used by each
4784
   offset range in the GOT.  FDCUR and CUR, that must be aligned to a
4785
   double-word boundary, are the minimum (negative) and maximum
4786
   (positive) GOT offsets already used by previous ranges, except for
4787
   an ODD entry that may have been left behind.  GOT and FD indicate
4788
   the size of GOT entries and function descriptors that must be
4789
   placed within the range from -WRAP to WRAP.  If there's room left,
4790
   up to FDPLT bytes should be reserved for additional function
4791
   descriptors.  */
4792
 
4793
inline static bfd_signed_vma
4794
_frvfdpic_compute_got_alloc_data (struct _frvfdpic_dynamic_got_alloc_data *gad,
4795
                                  bfd_signed_vma fdcur,
4796
                                  bfd_signed_vma odd,
4797
                                  bfd_signed_vma cur,
4798
                                  bfd_vma got,
4799
                                  bfd_vma fd,
4800
                                  bfd_vma fdplt,
4801
                                  bfd_vma tlsd,
4802
                                  bfd_vma tlsdplt,
4803
                                  bfd_vma wrap)
4804
{
4805
  bfd_signed_vma wrapmin = -wrap;
4806
  const bfd_vma tdescsz = 8;
4807
 
4808
  /* Start at the given initial points.  */
4809
  gad->fdcur = fdcur;
4810
  gad->cur = cur;
4811
 
4812
  /* If we had an incoming odd word and we have any got entries that
4813
     are going to use it, consume it, otherwise leave gad->odd at
4814
     zero.  We might force gad->odd to zero and return the incoming
4815
     odd such that it is used by the next range, but then GOT entries
4816
     might appear to be out of order and we wouldn't be able to
4817
     shorten the GOT by one word if it turns out to end with an
4818
     unpaired GOT entry.  */
4819
  if (odd && got)
4820
    {
4821
      gad->odd = odd;
4822
      got -= 4;
4823
      odd = 0;
4824
    }
4825
  else
4826
    gad->odd = 0;
4827
 
4828
  /* If we're left with an unpaired GOT entry, compute its location
4829
     such that we can return it.  Otherwise, if got doesn't require an
4830
     odd number of words here, either odd was already zero in the
4831
     block above, or it was set to zero because got was non-zero, or
4832
     got was already zero.  In the latter case, we want the value of
4833
     odd to carry over to the return statement, so we don't want to
4834
     reset odd unless the condition below is true.  */
4835
  if (got & 4)
4836
    {
4837
      odd = cur + got;
4838
      got += 4;
4839
    }
4840
 
4841
  /* Compute the tentative boundaries of this range.  */
4842
  gad->max = cur + got;
4843
  gad->min = fdcur - fd;
4844
  gad->fdplt = 0;
4845
 
4846
  /* If function descriptors took too much space, wrap some of them
4847
     around.  */
4848
  if (gad->min < wrapmin)
4849
    {
4850
      gad->max += wrapmin - gad->min;
4851
      gad->tmin = gad->min = wrapmin;
4852
    }
4853
 
4854
  /* If GOT entries took too much space, wrap some of them around.
4855
     This may well cause gad->min to become lower than wrapmin.  This
4856
     will cause a relocation overflow later on, so we don't have to
4857
     report it here . */
4858
  if ((bfd_vma) gad->max > wrap)
4859
    {
4860
      gad->min -= gad->max - wrap;
4861
      gad->max = wrap;
4862
    }
4863
 
4864
  /* Add TLS descriptors.  */
4865
  gad->tmax = gad->max + tlsd;
4866
  gad->tmin = gad->min;
4867
  gad->tlsdplt = 0;
4868
 
4869
  /* If TLS descriptors took too much space, wrap an integral number
4870
     of them around.  */
4871
  if ((bfd_vma) gad->tmax > wrap)
4872
    {
4873
      bfd_vma wrapsize = gad->tmax - wrap;
4874
 
4875
      wrapsize += tdescsz / 2;
4876
      wrapsize &= ~ tdescsz / 2;
4877
 
4878
      gad->tmin -= wrapsize;
4879
      gad->tmax -= wrapsize;
4880
    }
4881
 
4882
  /* If there is space left and we have function descriptors
4883
     referenced in PLT entries that could take advantage of shorter
4884
     offsets, place them now.  */
4885
  if (fdplt && gad->tmin > wrapmin)
4886
    {
4887
      bfd_vma fds;
4888
 
4889
      if ((bfd_vma) (gad->tmin - wrapmin) < fdplt)
4890
        fds = gad->tmin - wrapmin;
4891
      else
4892
        fds = fdplt;
4893
 
4894
      fdplt -= fds;
4895
      gad->min -= fds;
4896
      gad->tmin -= fds;
4897
      gad->fdplt += fds;
4898
    }
4899
 
4900
  /* If there is more space left, try to place some more function
4901
     descriptors for PLT entries.  */
4902
  if (fdplt && (bfd_vma) gad->tmax < wrap)
4903
    {
4904
      bfd_vma fds;
4905
 
4906
      if ((bfd_vma) (wrap - gad->tmax) < fdplt)
4907
        fds = wrap - gad->tmax;
4908
      else
4909
        fds = fdplt;
4910
 
4911
      fdplt -= fds;
4912
      gad->max += fds;
4913
      gad->tmax += fds;
4914
      gad->fdplt += fds;
4915
    }
4916
 
4917
  /* If there is space left and we have TLS descriptors referenced in
4918
     PLT entries that could take advantage of shorter offsets, place
4919
     them now.  */
4920
  if (tlsdplt && gad->tmin > wrapmin)
4921
    {
4922
      bfd_vma tlsds;
4923
 
4924
      if ((bfd_vma) (gad->tmin - wrapmin) < tlsdplt)
4925
        tlsds = (gad->tmin - wrapmin) & ~ (tdescsz / 2);
4926
      else
4927
        tlsds = tlsdplt;
4928
 
4929
      tlsdplt -= tlsds;
4930
      gad->tmin -= tlsds;
4931
      gad->tlsdplt += tlsds;
4932
    }
4933
 
4934
  /* If there is more space left, try to place some more TLS
4935
     descriptors for PLT entries.  Although we could try to fit an
4936
     additional TLS descriptor with half of it just before before the
4937
     wrap point and another right past the wrap point, this might
4938
     cause us to run out of space for the next region, so don't do
4939
     it.  */
4940
  if (tlsdplt && (bfd_vma) gad->tmax < wrap - tdescsz / 2)
4941
    {
4942
      bfd_vma tlsds;
4943
 
4944
      if ((bfd_vma) (wrap - gad->tmax) < tlsdplt)
4945
        tlsds = (wrap - gad->tmax) & ~ (tdescsz / 2);
4946
      else
4947
        tlsds = tlsdplt;
4948
 
4949
      tlsdplt -= tlsds;
4950
      gad->tmax += tlsds;
4951
      gad->tlsdplt += tlsds;
4952
    }
4953
 
4954
  /* If odd was initially computed as an offset past the wrap point,
4955
     wrap it around.  */
4956
  if (odd > gad->max)
4957
    odd = gad->min + odd - gad->max;
4958
 
4959
  /* _frvfdpic_get_got_entry() below will always wrap gad->cur if needed
4960
     before returning, so do it here too.  This guarantees that,
4961
     should cur and fdcur meet at the wrap point, they'll both be
4962
     equal to min.  */
4963
  if (gad->cur == gad->max)
4964
    gad->cur = gad->min;
4965
 
4966
  /* Ditto for _frvfdpic_get_tlsdesc_entry().  */
4967
  gad->tcur = gad->max;
4968
  if (gad->tcur == gad->tmax)
4969
    gad->tcur = gad->tmin;
4970
 
4971
  return odd;
4972
}
4973
 
4974
/* Compute the location of the next GOT entry, given the allocation
4975
   data for a range.  */
4976
 
4977
inline static bfd_signed_vma
4978
_frvfdpic_get_got_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
4979
{
4980
  bfd_signed_vma ret;
4981
 
4982
  if (gad->odd)
4983
    {
4984
      /* If there was an odd word left behind, use it.  */
4985
      ret = gad->odd;
4986
      gad->odd = 0;
4987
    }
4988
  else
4989
    {
4990
      /* Otherwise, use the word pointed to by cur, reserve the next
4991
         as an odd word, and skip to the next pair of words, possibly
4992
         wrapping around.  */
4993
      ret = gad->cur;
4994
      gad->odd = gad->cur + 4;
4995
      gad->cur += 8;
4996
      if (gad->cur == gad->max)
4997
        gad->cur = gad->min;
4998
    }
4999
 
5000
  return ret;
5001
}
5002
 
5003
/* Compute the location of the next function descriptor entry in the
5004
   GOT, given the allocation data for a range.  */
5005
 
5006
inline static bfd_signed_vma
5007
_frvfdpic_get_fd_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
5008
{
5009
  /* If we're at the bottom, wrap around, and only then allocate the
5010
     next pair of words.  */
5011
  if (gad->fdcur == gad->min)
5012
    gad->fdcur = gad->max;
5013
  return gad->fdcur -= 8;
5014
}
5015
 
5016
/* Compute the location of the next TLS descriptor entry in the GOT,
5017
   given the allocation data for a range.  */
5018
inline static bfd_signed_vma
5019
_frvfdpic_get_tlsdesc_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
5020
{
5021
  bfd_signed_vma ret;
5022
 
5023
  ret = gad->tcur;
5024
 
5025
  gad->tcur += 8;
5026
 
5027
  /* If we're at the top of the region, wrap around to the bottom.  */
5028
  if (gad->tcur == gad->tmax)
5029
    gad->tcur = gad->tmin;
5030
 
5031
  return ret;
5032
}
5033
 
5034
/* Assign GOT offsets for every GOT entry and function descriptor.
5035
   Doing everything in a single pass is tricky.  */
5036
 
5037
static int
5038
_frvfdpic_assign_got_entries (void **entryp, void *info_)
5039
{
5040
  struct frvfdpic_relocs_info *entry = *entryp;
5041
  struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
5042
 
5043
  if (entry->got12)
5044
    entry->got_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5045
  else if (entry->gotlos)
5046
    entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5047
  else if (entry->gothilo)
5048
    entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5049
 
5050
  if (entry->fdgot12)
5051
    entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5052
  else if (entry->fdgotlos)
5053
    entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5054
  else if (entry->fdgothilo)
5055
    entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5056
 
5057
  if (entry->fdgoff12)
5058
    entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
5059
  else if (entry->plt && dinfo->got12.fdplt)
5060
    {
5061
      dinfo->got12.fdplt -= 8;
5062
      entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
5063
    }
5064
  else if (entry->fdgofflos)
5065
    entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
5066
  else if (entry->plt && dinfo->gotlos.fdplt)
5067
    {
5068
      dinfo->gotlos.fdplt -= 8;
5069
      entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
5070
    }
5071
  else if (entry->plt)
5072
    {
5073
      dinfo->gothilo.fdplt -= 8;
5074
      entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5075
    }
5076
  else if (entry->privfd)
5077
    entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5078
 
5079
  if (entry->tlsoff12)
5080
    entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5081
  else if (entry->tlsofflos)
5082
    entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5083
  else if (entry->tlsoffhilo)
5084
    entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5085
 
5086
  if (entry->tlsdesc12)
5087
    entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5088
  else if (entry->tlsplt && dinfo->got12.tlsdplt)
5089
    {
5090
      dinfo->got12.tlsdplt -= 8;
5091
      entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5092
    }
5093
  else if (entry->tlsdesclos)
5094
    entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5095
  else if (entry->tlsplt && dinfo->gotlos.tlsdplt)
5096
    {
5097
      dinfo->gotlos.tlsdplt -= 8;
5098
      entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5099
    }
5100
  else if (entry->tlsplt)
5101
    {
5102
      dinfo->gothilo.tlsdplt -= 8;
5103
      entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5104
    }
5105
  else if (entry->tlsdeschilo)
5106
    entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5107
 
5108
  return 1;
5109
}
5110
 
5111
/* Assign GOT offsets to private function descriptors used by PLT
5112
   entries (or referenced by 32-bit offsets), as well as PLT entries
5113
   and lazy PLT entries.  */
5114
 
5115
static int
5116
_frvfdpic_assign_plt_entries (void **entryp, void *info_)
5117
{
5118
  struct frvfdpic_relocs_info *entry = *entryp;
5119
  struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
5120
 
5121
  if (entry->privfd)
5122
    BFD_ASSERT (entry->fd_entry);
5123
 
5124
  if (entry->plt)
5125
    {
5126
      int size;
5127
 
5128
      /* We use the section's raw size to mark the location of the
5129
         next PLT entry.  */
5130
      entry->plt_entry = frvfdpic_plt_section (dinfo->g.info)->size;
5131
 
5132
      /* Figure out the length of this PLT entry based on the
5133
         addressing mode we need to reach the function descriptor.  */
5134
      BFD_ASSERT (entry->fd_entry);
5135
      if (entry->fd_entry >= -(1 << (12 - 1))
5136
          && entry->fd_entry < (1 << (12 - 1)))
5137
        size = 8;
5138
      else if (entry->fd_entry >= -(1 << (16 - 1))
5139
               && entry->fd_entry < (1 << (16 - 1)))
5140
        size = 12;
5141
      else
5142
        size = 16;
5143
 
5144
      frvfdpic_plt_section (dinfo->g.info)->size += size;
5145
    }
5146
 
5147
  if (entry->lazyplt)
5148
    {
5149
      entry->lzplt_entry = dinfo->g.lzplt;
5150
      dinfo->g.lzplt += 8;
5151
      /* If this entry is the one that gets the resolver stub, account
5152
         for the additional instruction.  */
5153
      if (entry->lzplt_entry % FRVFDPIC_LZPLT_BLOCK_SIZE
5154
          == FRVFDPIC_LZPLT_RESOLV_LOC)
5155
        dinfo->g.lzplt += 4;
5156
    }
5157
 
5158
  if (entry->tlsplt)
5159
    {
5160
      int size;
5161
 
5162
      entry->tlsplt_entry
5163
        = frvfdpic_plt_section (dinfo->g.info)->size;
5164
 
5165
      if (dinfo->g.info->executable
5166
          && (entry->symndx != -1
5167
              || FRVFDPIC_SYM_LOCAL (dinfo->g.info, entry->d.h)))
5168
        {
5169
          if ((bfd_signed_vma)entry->addend >= -(1 << (16 - 1))
5170
              /* FIXME: here we use the size of the TLS section
5171
                 as an upper bound for the value of the TLS
5172
                 symbol, because we may not know the exact value
5173
                 yet.  If we get it wrong, we'll just waste a
5174
                 word in the PLT, and we should never get even
5175
                 close to 32 KiB of TLS anyway.  */
5176
              && elf_hash_table (dinfo->g.info)->tls_sec
5177
              && (elf_hash_table (dinfo->g.info)->tls_sec->size
5178
                  + (bfd_signed_vma)(entry->addend) <= (1 << (16 - 1))))
5179
            size = 8;
5180
          else
5181
            size = 12;
5182
        }
5183
      else if (entry->tlsoff_entry)
5184
        {
5185
          if (entry->tlsoff_entry >= -(1 << (12 - 1))
5186
              && entry->tlsoff_entry < (1 << (12 - 1)))
5187
            size = 8;
5188
          else if (entry->tlsoff_entry >= -(1 << (16 - 1))
5189
                   && entry->tlsoff_entry < (1 << (16 - 1)))
5190
            size = 12;
5191
          else
5192
            size = 16;
5193
        }
5194
      else
5195
        {
5196
          BFD_ASSERT (entry->tlsdesc_entry);
5197
 
5198
          if (entry->tlsdesc_entry >= -(1 << (12 - 1))
5199
              && entry->tlsdesc_entry < (1 << (12 - 1)))
5200
            size = 8;
5201
          else if (entry->tlsdesc_entry >= -(1 << (16 - 1))
5202
                   && entry->tlsdesc_entry < (1 << (16 - 1)))
5203
            size = 12;
5204
          else
5205
            size = 16;
5206
        }
5207
 
5208
      frvfdpic_plt_section (dinfo->g.info)->size += size;
5209
    }
5210
 
5211
  return 1;
5212
}
5213
 
5214
/* Cancel out any effects of calling _frvfdpic_assign_got_entries and
5215
   _frvfdpic_assign_plt_entries.  */
5216
 
5217
static int
5218
_frvfdpic_reset_got_plt_entries (void **entryp, void *ignore ATTRIBUTE_UNUSED)
5219
{
5220
  struct frvfdpic_relocs_info *entry = *entryp;
5221
 
5222
  entry->got_entry = 0;
5223
  entry->fdgot_entry = 0;
5224
  entry->fd_entry = 0;
5225
  entry->plt_entry = (bfd_vma)-1;
5226
  entry->lzplt_entry = (bfd_vma)-1;
5227
  entry->tlsoff_entry = 0;
5228
  entry->tlsdesc_entry = 0;
5229
  entry->tlsplt_entry = (bfd_vma)-1;
5230
 
5231
  return 1;
5232
}
5233
 
5234
/* Follow indirect and warning hash entries so that each got entry
5235
   points to the final symbol definition.  P must point to a pointer
5236
   to the hash table we're traversing.  Since this traversal may
5237
   modify the hash table, we set this pointer to NULL to indicate
5238
   we've made a potentially-destructive change to the hash table, so
5239
   the traversal must be restarted.  */
5240
static int
5241
_frvfdpic_resolve_final_relocs_info (void **entryp, void *p)
5242
{
5243
  struct frvfdpic_relocs_info *entry = *entryp;
5244
  htab_t *htab = p;
5245
 
5246
  if (entry->symndx == -1)
5247
    {
5248
      struct elf_link_hash_entry *h = entry->d.h;
5249
      struct frvfdpic_relocs_info *oentry;
5250
 
5251
      while (h->root.type == bfd_link_hash_indirect
5252
             || h->root.type == bfd_link_hash_warning)
5253
        h = (struct elf_link_hash_entry *)h->root.u.i.link;
5254
 
5255
      if (entry->d.h == h)
5256
        return 1;
5257
 
5258
      oentry = frvfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
5259
                                                NO_INSERT);
5260
 
5261
      if (oentry)
5262
        {
5263
          /* Merge the two entries.  */
5264
          frvfdpic_pic_merge_early_relocs_info (oentry, entry);
5265
          htab_clear_slot (*htab, entryp);
5266
          return 1;
5267
        }
5268
 
5269
      entry->d.h = h;
5270
 
5271
      /* If we can't find this entry with the new bfd hash, re-insert
5272
         it, and get the traversal restarted.  */
5273
      if (! htab_find (*htab, entry))
5274
        {
5275
          htab_clear_slot (*htab, entryp);
5276
          entryp = htab_find_slot (*htab, entry, INSERT);
5277
          if (! *entryp)
5278
            *entryp = entry;
5279
          /* Abort the traversal, since the whole table may have
5280
             moved, and leave it up to the parent to restart the
5281
             process.  */
5282
          *(htab_t *)p = NULL;
5283
          return 0;
5284
        }
5285
    }
5286
 
5287
  return 1;
5288
}
5289
 
5290
/* Compute the total size of the GOT, the PLT, the dynamic relocations
5291
   section and the rofixup section.  Assign locations for GOT and PLT
5292
   entries.  */
5293
 
5294
static bfd_boolean
5295
_frvfdpic_size_got_plt (bfd *output_bfd,
5296
                        struct _frvfdpic_dynamic_got_plt_info *gpinfop)
5297
{
5298
  bfd_signed_vma odd;
5299
  bfd_vma limit, tlslimit;
5300
  struct bfd_link_info *info = gpinfop->g.info;
5301
  bfd *dynobj = elf_hash_table (info)->dynobj;
5302
 
5303
  memcpy (frvfdpic_dynamic_got_plt_info (info), &gpinfop->g,
5304
          sizeof (gpinfop->g));
5305
 
5306
  odd = 12;
5307
  /* Compute the total size taken by entries in the 12-bit and 16-bit
5308
     ranges, to tell how many PLT function descriptors we can bring
5309
     into the 12-bit range without causing the 16-bit range to
5310
     overflow.  */
5311
  limit = odd + gpinfop->g.got12 + gpinfop->g.gotlos
5312
    + gpinfop->g.fd12 + gpinfop->g.fdlos
5313
    + gpinfop->g.tlsd12 + gpinfop->g.tlsdlos;
5314
  if (limit < (bfd_vma)1 << 16)
5315
    limit = ((bfd_vma)1 << 16) - limit;
5316
  else
5317
    limit = 0;
5318
  if (gpinfop->g.fdplt < limit)
5319
    {
5320
      tlslimit = (limit - gpinfop->g.fdplt) & ~ (bfd_vma) 8;
5321
      limit = gpinfop->g.fdplt;
5322
    }
5323
  else
5324
    tlslimit = 0;
5325
  if (gpinfop->g.tlsdplt < tlslimit)
5326
    tlslimit = gpinfop->g.tlsdplt;
5327
 
5328
  /* Determine the ranges of GOT offsets that we can use for each
5329
     range of addressing modes.  */
5330
  odd = _frvfdpic_compute_got_alloc_data (&gpinfop->got12,
5331
                                          0,
5332
                                          odd,
5333
                                          16,
5334
                                          gpinfop->g.got12,
5335
                                          gpinfop->g.fd12,
5336
                                          limit,
5337
                                          gpinfop->g.tlsd12,
5338
                                          tlslimit,
5339
                                          (bfd_vma)1 << (12-1));
5340
  odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gotlos,
5341
                                          gpinfop->got12.tmin,
5342
                                          odd,
5343
                                          gpinfop->got12.tmax,
5344
                                          gpinfop->g.gotlos,
5345
                                          gpinfop->g.fdlos,
5346
                                          gpinfop->g.fdplt
5347
                                          - gpinfop->got12.fdplt,
5348
                                          gpinfop->g.tlsdlos,
5349
                                          gpinfop->g.tlsdplt
5350
                                          - gpinfop->got12.tlsdplt,
5351
                                          (bfd_vma)1 << (16-1));
5352
  odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gothilo,
5353
                                          gpinfop->gotlos.tmin,
5354
                                          odd,
5355
                                          gpinfop->gotlos.tmax,
5356
                                          gpinfop->g.gothilo,
5357
                                          gpinfop->g.fdhilo,
5358
                                          gpinfop->g.fdplt
5359
                                          - gpinfop->got12.fdplt
5360
                                          - gpinfop->gotlos.fdplt,
5361
                                          gpinfop->g.tlsdhilo,
5362
                                          gpinfop->g.tlsdplt
5363
                                          - gpinfop->got12.tlsdplt
5364
                                          - gpinfop->gotlos.tlsdplt,
5365
                                          (bfd_vma)1 << (32-1));
5366
 
5367
  /* Now assign (most) GOT offsets.  */
5368
  htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_got_entries,
5369
                 gpinfop);
5370
 
5371
  frvfdpic_got_section (info)->size = gpinfop->gothilo.tmax
5372
    - gpinfop->gothilo.tmin
5373
    /* If an odd word is the last word of the GOT, we don't need this
5374
       word to be part of the GOT.  */
5375
    - (odd + 4 == gpinfop->gothilo.tmax ? 4 : 0);
5376
  if (frvfdpic_got_section (info)->size == 0)
5377
    frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
5378
  else if (frvfdpic_got_section (info)->size == 12
5379
           && ! elf_hash_table (info)->dynamic_sections_created)
5380
    {
5381
      frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
5382
      frvfdpic_got_section (info)->size = 0;
5383
    }
5384
  /* This will be non-NULL during relaxation.  The assumption is that
5385
     the size of one of these sections will never grow, only shrink,
5386
     so we can use the larger buffer we allocated before.  */
5387
  else if (frvfdpic_got_section (info)->contents == NULL)
5388
    {
5389
      frvfdpic_got_section (info)->contents =
5390
        (bfd_byte *) bfd_zalloc (dynobj,
5391
                                 frvfdpic_got_section (info)->size);
5392
      if (frvfdpic_got_section (info)->contents == NULL)
5393
        return FALSE;
5394
    }
5395
 
5396
  if (frvfdpic_gotrel_section (info))
5397
    /* Subtract the number of lzplt entries, since those will generate
5398
       relocations in the pltrel section.  */
5399
    frvfdpic_gotrel_section (info)->size =
5400
      (gpinfop->g.relocs - gpinfop->g.lzplt / 8)
5401
      * get_elf_backend_data (output_bfd)->s->sizeof_rel;
5402
  else
5403
    BFD_ASSERT (gpinfop->g.relocs == 0);
5404
  if (frvfdpic_gotrel_section (info)->size == 0)
5405
    frvfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
5406
  else if (frvfdpic_gotrel_section (info)->contents == NULL)
5407
    {
5408
      frvfdpic_gotrel_section (info)->contents =
5409
        (bfd_byte *) bfd_zalloc (dynobj,
5410
                                 frvfdpic_gotrel_section (info)->size);
5411
      if (frvfdpic_gotrel_section (info)->contents == NULL)
5412
        return FALSE;
5413
    }
5414
 
5415
  frvfdpic_gotfixup_section (info)->size = (gpinfop->g.fixups + 1) * 4;
5416
  if (frvfdpic_gotfixup_section (info)->size == 0)
5417
    frvfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
5418
  else if (frvfdpic_gotfixup_section (info)->contents == NULL)
5419
    {
5420
      frvfdpic_gotfixup_section (info)->contents =
5421
        (bfd_byte *) bfd_zalloc (dynobj,
5422
                                 frvfdpic_gotfixup_section (info)->size);
5423
      if (frvfdpic_gotfixup_section (info)->contents == NULL)
5424
        return FALSE;
5425
    }
5426
 
5427
  if (frvfdpic_pltrel_section (info))
5428
    {
5429
      frvfdpic_pltrel_section (info)->size =
5430
        gpinfop->g.lzplt / 8
5431
        * get_elf_backend_data (output_bfd)->s->sizeof_rel;
5432
      if (frvfdpic_pltrel_section (info)->size == 0)
5433
        frvfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
5434
      else if (frvfdpic_pltrel_section (info)->contents == NULL)
5435
        {
5436
          frvfdpic_pltrel_section (info)->contents =
5437
            (bfd_byte *) bfd_zalloc (dynobj,
5438
                                     frvfdpic_pltrel_section (info)->size);
5439
          if (frvfdpic_pltrel_section (info)->contents == NULL)
5440
            return FALSE;
5441
        }
5442
    }
5443
 
5444
  /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
5445
     such that there's room for the additional instruction needed to
5446
     call the resolver.  Since _frvfdpic_assign_got_entries didn't
5447
     account for them, our block size is 4 bytes smaller than the real
5448
     block size.  */
5449
  if (frvfdpic_plt_section (info))
5450
    {
5451
      frvfdpic_plt_section (info)->size = gpinfop->g.lzplt
5452
        + ((gpinfop->g.lzplt + (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) - 8)
5453
           / (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) * 4);
5454
    }
5455
 
5456
  /* Reset it, such that _frvfdpic_assign_plt_entries() can use it to
5457
     actually assign lazy PLT entries addresses.  */
5458
  gpinfop->g.lzplt = 0;
5459
 
5460
  /* Save information that we're going to need to generate GOT and PLT
5461
     entries.  */
5462
  frvfdpic_got_initial_offset (info) = -gpinfop->gothilo.tmin;
5463
 
5464
  if (get_elf_backend_data (output_bfd)->want_got_sym)
5465
    elf_hash_table (info)->hgot->root.u.def.value
5466
      = frvfdpic_got_initial_offset (info);
5467
 
5468
  if (frvfdpic_plt_section (info))
5469
    frvfdpic_plt_initial_offset (info) =
5470
      frvfdpic_plt_section (info)->size;
5471
 
5472
  /* Allocate a ret statement at plt_initial_offset, to be used by
5473
     locally-resolved TLS descriptors.  */
5474
  if (gpinfop->g.tls_ret_refs)
5475
    frvfdpic_plt_section (info)->size += 4;
5476
 
5477
  htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_plt_entries,
5478
                 gpinfop);
5479
 
5480
  /* Allocate the PLT section contents only after
5481
     _frvfdpic_assign_plt_entries has a chance to add the size of the
5482
     non-lazy PLT entries.  */
5483
  if (frvfdpic_plt_section (info))
5484
    {
5485
      if (frvfdpic_plt_section (info)->size == 0)
5486
        frvfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
5487
      else if (frvfdpic_plt_section (info)->contents == NULL)
5488
        {
5489
          frvfdpic_plt_section (info)->contents =
5490
            (bfd_byte *) bfd_zalloc (dynobj,
5491
                                     frvfdpic_plt_section (info)->size);
5492
          if (frvfdpic_plt_section (info)->contents == NULL)
5493
            return FALSE;
5494
        }
5495
    }
5496
 
5497
  return TRUE;
5498
}
5499
 
5500
/* Set the sizes of the dynamic sections.  */
5501
 
5502
static bfd_boolean
5503
elf32_frvfdpic_size_dynamic_sections (bfd *output_bfd,
5504
                                      struct bfd_link_info *info)
5505
{
5506
  bfd *dynobj;
5507
  asection *s;
5508
  struct _frvfdpic_dynamic_got_plt_info gpinfo;
5509
 
5510
  dynobj = elf_hash_table (info)->dynobj;
5511
  BFD_ASSERT (dynobj != NULL);
5512
 
5513
  if (elf_hash_table (info)->dynamic_sections_created)
5514
    {
5515
      /* Set the contents of the .interp section to the interpreter.  */
5516
      if (info->executable)
5517
        {
5518
          s = bfd_get_section_by_name (dynobj, ".interp");
5519
          BFD_ASSERT (s != NULL);
5520
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5521
          s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
5522
        }
5523
    }
5524
 
5525
  memset (&gpinfo, 0, sizeof (gpinfo));
5526
  gpinfo.g.info = info;
5527
 
5528
  for (;;)
5529
    {
5530
      htab_t relocs = frvfdpic_relocs_info (info);
5531
 
5532
      htab_traverse (relocs, _frvfdpic_resolve_final_relocs_info, &relocs);
5533
 
5534
      if (relocs == frvfdpic_relocs_info (info))
5535
        break;
5536
    }
5537
 
5538
  htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_count_got_plt_entries,
5539
                 &gpinfo.g);
5540
 
5541
  /* Allocate space to save the summary information, we're going to
5542
     use it if we're doing relaxations.  */
5543
  frvfdpic_dynamic_got_plt_info (info) = bfd_alloc (dynobj, sizeof (gpinfo.g));
5544
 
5545
  if (!_frvfdpic_size_got_plt (output_bfd, &gpinfo))
5546
    return FALSE;
5547
 
5548
  if (elf_hash_table (info)->dynamic_sections_created)
5549
    {
5550
      if (frvfdpic_got_section (info)->size)
5551
        if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
5552
          return FALSE;
5553
 
5554
      if (frvfdpic_pltrel_section (info)->size)
5555
        if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
5556
            || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
5557
            || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
5558
          return FALSE;
5559
 
5560
      if (frvfdpic_gotrel_section (info)->size)
5561
        if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
5562
            || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
5563
            || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
5564
                                            sizeof (Elf32_External_Rel)))
5565
          return FALSE;
5566
    }
5567
 
5568
  return TRUE;
5569
}
5570
 
5571
static bfd_boolean
5572
elf32_frvfdpic_always_size_sections (bfd *output_bfd,
5573
                                     struct bfd_link_info *info)
5574
{
5575
  if (!info->relocatable)
5576
    {
5577
      struct elf_link_hash_entry *h;
5578
 
5579
      /* Force a PT_GNU_STACK segment to be created.  */
5580
      if (! elf_tdata (output_bfd)->stack_flags)
5581
        elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
5582
 
5583
      /* Define __stacksize if it's not defined yet.  */
5584
      h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
5585
                                FALSE, FALSE, FALSE);
5586
      if (! h || h->root.type != bfd_link_hash_defined
5587
          || h->type != STT_OBJECT
5588
          || !h->def_regular)
5589
        {
5590
          struct bfd_link_hash_entry *bh = NULL;
5591
 
5592
          if (!(_bfd_generic_link_add_one_symbol
5593
                (info, output_bfd, "__stacksize",
5594
                 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
5595
                 (const char *) NULL, FALSE,
5596
                 get_elf_backend_data (output_bfd)->collect, &bh)))
5597
            return FALSE;
5598
 
5599
          h = (struct elf_link_hash_entry *) bh;
5600
          h->def_regular = 1;
5601
          h->type = STT_OBJECT;
5602
          /* This one must NOT be hidden.  */
5603
        }
5604
    }
5605
 
5606
  return TRUE;
5607
}
5608
 
5609
/* Check whether any of the relocations was optimized away, and
5610
   subtract it from the relocation or fixup count.  */
5611
static bfd_boolean
5612
_frvfdpic_check_discarded_relocs (bfd *abfd, asection *sec,
5613
                                  struct bfd_link_info *info,
5614
 
5615
                                  bfd_boolean *changed)
5616
{
5617
  Elf_Internal_Shdr *symtab_hdr;
5618
  struct elf_link_hash_entry **sym_hashes;
5619
  Elf_Internal_Rela *rel, *erel;
5620
 
5621
  if ((sec->flags & SEC_RELOC) == 0
5622
      || sec->reloc_count == 0)
5623
    return TRUE;
5624
 
5625
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5626
  sym_hashes = elf_sym_hashes (abfd);
5627
 
5628
  rel = elf_section_data (sec)->relocs;
5629
 
5630
  /* Now examine each relocation.  */
5631
  for (erel = rel + sec->reloc_count; rel < erel; rel++)
5632
    {
5633
      struct elf_link_hash_entry *h;
5634
      unsigned long r_symndx;
5635
      struct frvfdpic_relocs_info *picrel;
5636
      struct _frvfdpic_dynamic_got_info *dinfo;
5637
 
5638
      if (ELF32_R_TYPE (rel->r_info) != R_FRV_32
5639
          && ELF32_R_TYPE (rel->r_info) != R_FRV_FUNCDESC)
5640
        continue;
5641
 
5642
      if (_bfd_elf_section_offset (sec->output_section->owner,
5643
                                   info, sec, rel->r_offset)
5644
          != (bfd_vma)-1)
5645
        continue;
5646
 
5647
      r_symndx = ELF32_R_SYM (rel->r_info);
5648
      if (r_symndx < symtab_hdr->sh_info)
5649
        h = NULL;
5650
      else
5651
        {
5652
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5653
          while (h->root.type == bfd_link_hash_indirect
5654
                 || h->root.type == bfd_link_hash_warning)
5655
            h = (struct elf_link_hash_entry *)h->root.u.i.link;
5656
        }
5657
 
5658
      if (h != NULL)
5659
        picrel = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info),
5660
                                                  abfd, h,
5661
                                                  rel->r_addend, NO_INSERT);
5662
      else
5663
        picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info (info),
5664
                                                 abfd, r_symndx,
5665
                                                 rel->r_addend, NO_INSERT);
5666
 
5667
      if (! picrel)
5668
        return FALSE;
5669
 
5670
      *changed = TRUE;
5671
      dinfo = frvfdpic_dynamic_got_plt_info (info);
5672
 
5673
      _frvfdpic_count_relocs_fixups (picrel, dinfo, TRUE);
5674
      if (ELF32_R_TYPE (rel->r_info) == R_FRV_32)
5675
        picrel->relocs32--;
5676
      else /* we know (ELF32_R_TYPE (rel->r_info) == R_FRV_FUNCDESC) */
5677
        picrel->relocsfd--;
5678
      _frvfdpic_count_relocs_fixups (picrel, dinfo, FALSE);
5679
    }
5680
 
5681
  return TRUE;
5682
}
5683
 
5684
static bfd_boolean
5685
frvfdpic_elf_discard_info (bfd *ibfd,
5686
                           struct elf_reloc_cookie *cookie ATTRIBUTE_UNUSED,
5687
                           struct bfd_link_info *info)
5688
{
5689
  bfd_boolean changed = FALSE;
5690
  asection *s;
5691
  bfd *obfd = NULL;
5692
 
5693
  /* Account for relaxation of .eh_frame section.  */
5694
  for (s = ibfd->sections; s; s = s->next)
5695
    if (s->sec_info_type == ELF_INFO_TYPE_EH_FRAME)
5696
      {
5697
        if (!_frvfdpic_check_discarded_relocs (ibfd, s, info, &changed))
5698
          return FALSE;
5699
        obfd = s->output_section->owner;
5700
      }
5701
 
5702
  if (changed)
5703
    {
5704
      struct _frvfdpic_dynamic_got_plt_info gpinfo;
5705
 
5706
      memset (&gpinfo, 0, sizeof (gpinfo));
5707
      memcpy (&gpinfo.g, frvfdpic_dynamic_got_plt_info (info),
5708
              sizeof (gpinfo.g));
5709
 
5710
      /* Clear GOT and PLT assignments.  */
5711
      htab_traverse (frvfdpic_relocs_info (info),
5712
                     _frvfdpic_reset_got_plt_entries,
5713
                     NULL);
5714
 
5715
      if (!_frvfdpic_size_got_plt (obfd, &gpinfo))
5716
        return FALSE;
5717
    }
5718
 
5719
  return TRUE;
5720
}
5721
 
5722
/* Look for opportunities to relax TLS relocations.  We can assume
5723
   we're linking the main executable or a static-tls library, since
5724
   otherwise we wouldn't have got here.  */
5725
 
5726
static int
5727
_frvfdpic_relax_got_plt_entries (void **entryp, void *dinfo_)
5728
{
5729
  struct frvfdpic_relocs_info *entry = *entryp;
5730
  struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
5731
 
5732
  _frvfdpic_relax_tls_entries (entry, dinfo, TRUE);
5733
 
5734
  return 1;
5735
}
5736
 
5737
static bfd_boolean
5738
elf32_frvfdpic_relax_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
5739
                              struct bfd_link_info *info, bfd_boolean *again)
5740
{
5741
  struct _frvfdpic_dynamic_got_plt_info gpinfo;
5742
 
5743
  if (info->relocatable)
5744
    (*info->callbacks->einfo)
5745
      (_("%P%F: --relax and -r may not be used together\n"));
5746
 
5747
  /* If we return early, we didn't change anything.  */
5748
  *again = FALSE;
5749
 
5750
  /* We'll do our thing when requested to relax the GOT section.  */
5751
  if (sec != frvfdpic_got_section (info))
5752
    return TRUE;
5753
 
5754
  /* We can only relax when linking the main executable or a library
5755
     that can't be dlopened.  */
5756
  if (! info->executable && ! (info->flags & DF_STATIC_TLS))
5757
    return TRUE;
5758
 
5759
  /* If there isn't a TLS section for this binary, we can't do
5760
     anything about its TLS relocations (it probably doesn't have
5761
     any.  */
5762
  if (elf_hash_table (info)->tls_sec == NULL)
5763
    return TRUE;
5764
 
5765
  memset (&gpinfo, 0, sizeof (gpinfo));
5766
  memcpy (&gpinfo.g, frvfdpic_dynamic_got_plt_info (info), sizeof (gpinfo.g));
5767
 
5768
  /* Now look for opportunities to relax, adjusting the GOT usage
5769
     as needed.  */
5770
  htab_traverse (frvfdpic_relocs_info (info),
5771
                 _frvfdpic_relax_got_plt_entries,
5772
                 &gpinfo.g);
5773
 
5774
  /* If we changed anything, reset and re-assign GOT and PLT entries.  */
5775
  if (memcmp (frvfdpic_dynamic_got_plt_info (info),
5776
              &gpinfo.g, sizeof (gpinfo.g)) != 0)
5777
    {
5778
      /* Clear GOT and PLT assignments.  */
5779
      htab_traverse (frvfdpic_relocs_info (info),
5780
                     _frvfdpic_reset_got_plt_entries,
5781
                     NULL);
5782
 
5783
      /* The owner of the TLS section is the output bfd.  There should
5784
         be a better way to get to it.  */
5785
      if (!_frvfdpic_size_got_plt (elf_hash_table (info)->tls_sec->owner,
5786
                                   &gpinfo))
5787
        return FALSE;
5788
 
5789
      /* Repeat until we don't make any further changes.  We could fail to
5790
         introduce changes in a round if, for example, the 12-bit range is
5791
         full, but we later release some space by getting rid of TLS
5792
         descriptors in it.  We have to repeat the whole process because
5793
         we might have changed the size of a section processed before this
5794
         one.  */
5795
      *again = TRUE;
5796
    }
5797
 
5798
  return TRUE;
5799
}
5800
 
5801
static bfd_boolean
5802
elf32_frvfdpic_modify_program_headers (bfd *output_bfd,
5803
                                       struct bfd_link_info *info)
5804
{
5805
  struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
5806
  struct elf_segment_map *m;
5807
  Elf_Internal_Phdr *p;
5808
 
5809
  /* objcopy and strip preserve what's already there using
5810
     elf32_frvfdpic_copy_private_bfd_data ().  */
5811
  if (! info)
5812
    return TRUE;
5813
 
5814
  for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
5815
    if (m->p_type == PT_GNU_STACK)
5816
      break;
5817
 
5818
  if (m)
5819
    {
5820
      struct elf_link_hash_entry *h;
5821
 
5822
      /* Obtain the pointer to the __stacksize symbol.  */
5823
      h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
5824
                                FALSE, FALSE, FALSE);
5825
      if (h)
5826
        {
5827
          while (h->root.type == bfd_link_hash_indirect
5828
                 || h->root.type == bfd_link_hash_warning)
5829
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
5830
          BFD_ASSERT (h->root.type == bfd_link_hash_defined);
5831
        }
5832
 
5833
      /* Set the header p_memsz from the symbol value.  We
5834
         intentionally ignore the symbol section.  */
5835
      if (h && h->root.type == bfd_link_hash_defined)
5836
        p->p_memsz = h->root.u.def.value;
5837
      else
5838
        p->p_memsz = DEFAULT_STACK_SIZE;
5839
 
5840
      p->p_align = 8;
5841
    }
5842
 
5843
  return TRUE;
5844
}
5845
 
5846
/* Fill in code and data in dynamic sections.  */
5847
 
5848
static bfd_boolean
5849
elf32_frv_finish_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5850
                                   struct bfd_link_info *info ATTRIBUTE_UNUSED)
5851
{
5852
  /* Nothing to be done for non-FDPIC.  */
5853
  return TRUE;
5854
}
5855
 
5856
static bfd_boolean
5857
elf32_frvfdpic_finish_dynamic_sections (bfd *output_bfd,
5858
                                        struct bfd_link_info *info)
5859
{
5860
  bfd *dynobj;
5861
  asection *sdyn;
5862
 
5863
  dynobj = elf_hash_table (info)->dynobj;
5864
 
5865
  if (frvfdpic_dynamic_got_plt_info (info))
5866
    {
5867
      BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs == 0);
5868
    }
5869
  if (frvfdpic_got_section (info))
5870
    {
5871
      BFD_ASSERT (frvfdpic_gotrel_section (info)->size
5872
                  == (frvfdpic_gotrel_section (info)->reloc_count
5873
                      * sizeof (Elf32_External_Rel)));
5874
 
5875
      if (frvfdpic_gotfixup_section (info))
5876
        {
5877
          struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
5878
          bfd_vma got_value = hgot->root.u.def.value
5879
            + hgot->root.u.def.section->output_section->vma
5880
            + hgot->root.u.def.section->output_offset;
5881
          struct bfd_link_hash_entry *hend;
5882
 
5883
          _frvfdpic_add_rofixup (output_bfd, frvfdpic_gotfixup_section (info),
5884
                                 got_value, 0);
5885
 
5886
          if (frvfdpic_gotfixup_section (info)->size
5887
              != (frvfdpic_gotfixup_section (info)->reloc_count * 4))
5888
            {
5889
            error:
5890
              (*_bfd_error_handler)
5891
                ("LINKER BUG: .rofixup section size mismatch");
5892
              return FALSE;
5893
            }
5894
 
5895
          hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
5896
                                       FALSE, FALSE, TRUE);
5897
          if (hend
5898
              && (hend->type == bfd_link_hash_defined
5899
                  || hend->type == bfd_link_hash_defweak))
5900
            {
5901
              bfd_vma value =
5902
                frvfdpic_gotfixup_section (info)->output_section->vma
5903
                + frvfdpic_gotfixup_section (info)->output_offset
5904
                + frvfdpic_gotfixup_section (info)->size
5905
                - hend->u.def.section->output_section->vma
5906
                - hend->u.def.section->output_offset;
5907
              BFD_ASSERT (hend->u.def.value == value);
5908
              if (hend->u.def.value != value)
5909
                goto error;
5910
            }
5911
        }
5912
    }
5913
  if (frvfdpic_pltrel_section (info))
5914
    {
5915
      BFD_ASSERT (frvfdpic_pltrel_section (info)->size
5916
                  == (frvfdpic_pltrel_section (info)->reloc_count
5917
                      * sizeof (Elf32_External_Rel)));
5918
    }
5919
 
5920
 
5921
  if (elf_hash_table (info)->dynamic_sections_created)
5922
    {
5923
      Elf32_External_Dyn * dyncon;
5924
      Elf32_External_Dyn * dynconend;
5925
 
5926
      sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5927
 
5928
      BFD_ASSERT (sdyn != NULL);
5929
 
5930
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
5931
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5932
 
5933
      for (; dyncon < dynconend; dyncon++)
5934
        {
5935
          Elf_Internal_Dyn dyn;
5936
 
5937
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5938
 
5939
          switch (dyn.d_tag)
5940
            {
5941
            default:
5942
              break;
5943
 
5944
            case DT_PLTGOT:
5945
              dyn.d_un.d_ptr = frvfdpic_got_section (info)->output_section->vma
5946
                + frvfdpic_got_section (info)->output_offset
5947
                + frvfdpic_got_initial_offset (info);
5948
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5949
              break;
5950
 
5951
            case DT_JMPREL:
5952
              dyn.d_un.d_ptr = frvfdpic_pltrel_section (info)
5953
                ->output_section->vma
5954
                + frvfdpic_pltrel_section (info)->output_offset;
5955
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5956
              break;
5957
 
5958
            case DT_PLTRELSZ:
5959
              dyn.d_un.d_val = frvfdpic_pltrel_section (info)->size;
5960
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5961
              break;
5962
            }
5963
        }
5964
    }
5965
 
5966
  return TRUE;
5967
}
5968
 
5969
/* Adjust a symbol defined by a dynamic object and referenced by a
5970
   regular object.  */
5971
 
5972
static bfd_boolean
5973
elf32_frvfdpic_adjust_dynamic_symbol
5974
(struct bfd_link_info *info ATTRIBUTE_UNUSED,
5975
 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
5976
{
5977
  bfd * dynobj;
5978
 
5979
  dynobj = elf_hash_table (info)->dynobj;
5980
 
5981
  /* Make sure we know what is going on here.  */
5982
  BFD_ASSERT (dynobj != NULL
5983
              && (h->u.weakdef != NULL
5984
                  || (h->def_dynamic
5985
                      && h->ref_regular
5986
                      && !h->def_regular)));
5987
 
5988
  /* If this is a weak symbol, and there is a real definition, the
5989
     processor independent code will have arranged for us to see the
5990
     real definition first, and we can just use the same value.  */
5991
  if (h->u.weakdef != NULL)
5992
    {
5993
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5994
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
5995
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
5996
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
5997
    }
5998
 
5999
  return TRUE;
6000
}
6001
 
6002
/* Perform any actions needed for dynamic symbols.  */
6003
 
6004
static bfd_boolean
6005
elf32_frvfdpic_finish_dynamic_symbol
6006
(bfd *output_bfd ATTRIBUTE_UNUSED,
6007
 struct bfd_link_info *info ATTRIBUTE_UNUSED,
6008
 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
6009
 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
6010
{
6011
  return TRUE;
6012
}
6013
 
6014
/* Decide whether to attempt to turn absptr or lsda encodings in
6015
   shared libraries into pcrel within the given input section.  */
6016
 
6017
static bfd_boolean
6018
frvfdpic_elf_use_relative_eh_frame
6019
(bfd *input_bfd ATTRIBUTE_UNUSED,
6020
 struct bfd_link_info *info ATTRIBUTE_UNUSED,
6021
 asection *eh_frame_section ATTRIBUTE_UNUSED)
6022
{
6023
  /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
6024
  return FALSE;
6025
}
6026
 
6027
/* Adjust the contents of an eh_frame_hdr section before they're output.  */
6028
 
6029
static bfd_byte
6030
frvfdpic_elf_encode_eh_address (bfd *abfd,
6031
                                struct bfd_link_info *info,
6032
                                asection *osec, bfd_vma offset,
6033
                                asection *loc_sec, bfd_vma loc_offset,
6034
                                bfd_vma *encoded)
6035
{
6036
  struct elf_link_hash_entry *h;
6037
 
6038
  h = elf_hash_table (info)->hgot;
6039
  BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
6040
 
6041
  if (! h || (_frvfdpic_osec_to_segment (abfd, osec)
6042
              == _frvfdpic_osec_to_segment (abfd, loc_sec->output_section)))
6043
    return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
6044
                                       loc_sec, loc_offset, encoded);
6045
 
6046
  BFD_ASSERT (_frvfdpic_osec_to_segment (abfd, osec)
6047
              == (_frvfdpic_osec_to_segment
6048
                  (abfd, h->root.u.def.section->output_section)));
6049
 
6050
  *encoded = osec->vma + offset
6051
    - (h->root.u.def.value
6052
       + h->root.u.def.section->output_section->vma
6053
       + h->root.u.def.section->output_offset);
6054
 
6055
  return DW_EH_PE_datarel | DW_EH_PE_sdata4;
6056
}
6057
 
6058
/* Look through the relocs for a section during the first phase.
6059
 
6060
   Besides handling virtual table relocs for gc, we have to deal with
6061
   all sorts of PIC-related relocations.  We describe below the
6062
   general plan on how to handle such relocations, even though we only
6063
   collect information at this point, storing them in hash tables for
6064
   perusal of later passes.
6065
 
6066
   32 relocations are propagated to the linker output when creating
6067
   position-independent output.  LO16 and HI16 relocations are not
6068
   supposed to be encountered in this case.
6069
 
6070
   LABEL16 should always be resolvable by the linker, since it's only
6071
   used by branches.
6072
 
6073
   LABEL24, on the other hand, is used by calls.  If it turns out that
6074
   the target of a call is a dynamic symbol, a PLT entry must be
6075
   created for it, which triggers the creation of a private function
6076
   descriptor and, unless lazy binding is disabled, a lazy PLT entry.
6077
 
6078
   GPREL relocations require the referenced symbol to be in the same
6079
   segment as _gp, but this can only be checked later.
6080
 
6081
   All GOT, GOTOFF and FUNCDESC relocations require a .got section to
6082
   exist.  LABEL24 might as well, since it may require a PLT entry,
6083
   that will require a got.
6084
 
6085
   Non-FUNCDESC GOT relocations require a GOT entry to be created
6086
   regardless of whether the symbol is dynamic.  However, since a
6087
   global symbol that turns out to not be exported may have the same
6088
   address of a non-dynamic symbol, we don't assign GOT entries at
6089
   this point, such that we can share them in this case.  A relocation
6090
   for the GOT entry always has to be created, be it to offset a
6091
   private symbol by the section load address, be it to get the symbol
6092
   resolved dynamically.
6093
 
6094
   FUNCDESC GOT relocations require a GOT entry to be created, and
6095
   handled as if a FUNCDESC relocation was applied to the GOT entry in
6096
   an object file.
6097
 
6098
   FUNCDESC relocations referencing a symbol that turns out to NOT be
6099
   dynamic cause a private function descriptor to be created.  The
6100
   FUNCDESC relocation then decays to a 32 relocation that points at
6101
   the private descriptor.  If the symbol is dynamic, the FUNCDESC
6102
   relocation is propagated to the linker output, such that the
6103
   dynamic linker creates the canonical descriptor, pointing to the
6104
   dynamically-resolved definition of the function.
6105
 
6106
   Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
6107
   symbols that are assigned to the same segment as the GOT, but we
6108
   can only check this later, after we know the complete set of
6109
   symbols defined and/or exported.
6110
 
6111
   FUNCDESC GOTOFF relocations require a function descriptor to be
6112
   created and, unless lazy binding is disabled or the symbol is not
6113
   dynamic, a lazy PLT entry.  Since we can't tell at this point
6114
   whether a symbol is going to be dynamic, we have to decide later
6115
   whether to create a lazy PLT entry or bind the descriptor directly
6116
   to the private function.
6117
 
6118
   FUNCDESC_VALUE relocations are not supposed to be present in object
6119
   files, but they may very well be simply propagated to the linker
6120
   output, since they have no side effect.
6121
 
6122
 
6123
   A function descriptor always requires a FUNCDESC_VALUE relocation.
6124
   Whether it's in .plt.rel or not depends on whether lazy binding is
6125
   enabled and on whether the referenced symbol is dynamic.
6126
 
6127
   The existence of a lazy PLT requires the resolverStub lazy PLT
6128
   entry to be present.
6129
 
6130
 
6131
   As for assignment of GOT, PLT and lazy PLT entries, and private
6132
   descriptors, we might do them all sequentially, but we can do
6133
   better than that.  For example, we can place GOT entries and
6134
   private function descriptors referenced using 12-bit operands
6135
   closer to the PIC register value, such that these relocations don't
6136
   overflow.  Those that are only referenced with LO16 relocations
6137
   could come next, but we may as well place PLT-required function
6138
   descriptors in the 12-bit range to make them shorter.  Symbols
6139
   referenced with LO16/HI16 may come next, but we may place
6140
   additional function descriptors in the 16-bit range if we can
6141
   reliably tell that we've already placed entries that are ever
6142
   referenced with only LO16.  PLT entries are therefore generated as
6143
   small as possible, while not introducing relocation overflows in
6144
   GOT or FUNCDESC_GOTOFF relocations.  Lazy PLT entries could be
6145
   generated before or after PLT entries, but not intermingled with
6146
   them, such that we can have more lazy PLT entries in range for a
6147
   branch to the resolverStub.  The resolverStub should be emitted at
6148
   the most distant location from the first lazy PLT entry such that
6149
   it's still in range for a branch, or closer, if there isn't a need
6150
   for so many lazy PLT entries.  Additional lazy PLT entries may be
6151
   emitted after the resolverStub, as long as branches are still in
6152
   range.  If the branch goes out of range, longer lazy PLT entries
6153
   are emitted.
6154
 
6155
   We could further optimize PLT and lazy PLT entries by giving them
6156
   priority in assignment to closer-to-gr17 locations depending on the
6157
   number of occurrences of references to them (assuming a function
6158
   that's called more often is more important for performance, so its
6159
   PLT entry should be faster), or taking hints from the compiler.
6160
   Given infinite time and money... :-)  */
6161
 
6162
static bfd_boolean
6163
elf32_frv_check_relocs (abfd, info, sec, relocs)
6164
     bfd *abfd;
6165
     struct bfd_link_info *info;
6166
     asection *sec;
6167
     const Elf_Internal_Rela *relocs;
6168
{
6169
  Elf_Internal_Shdr *symtab_hdr;
6170
  struct elf_link_hash_entry **sym_hashes;
6171
  const Elf_Internal_Rela *rel;
6172
  const Elf_Internal_Rela *rel_end;
6173
  bfd *dynobj;
6174
  struct frvfdpic_relocs_info *picrel;
6175
 
6176
  if (info->relocatable)
6177
    return TRUE;
6178
 
6179
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6180
  sym_hashes = elf_sym_hashes (abfd);
6181
 
6182
  dynobj = elf_hash_table (info)->dynobj;
6183
  rel_end = relocs + sec->reloc_count;
6184
  for (rel = relocs; rel < rel_end; rel++)
6185
    {
6186
      struct elf_link_hash_entry *h;
6187
      unsigned long r_symndx;
6188
 
6189
      r_symndx = ELF32_R_SYM (rel->r_info);
6190
      if (r_symndx < symtab_hdr->sh_info)
6191
        h = NULL;
6192
      else
6193
        {
6194
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6195
          while (h->root.type == bfd_link_hash_indirect
6196
                 || h->root.type == bfd_link_hash_warning)
6197
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
6198
        }
6199
 
6200
      switch (ELF32_R_TYPE (rel->r_info))
6201
        {
6202
        case R_FRV_GETTLSOFF:
6203
        case R_FRV_TLSDESC_VALUE:
6204
        case R_FRV_GOTTLSDESC12:
6205
        case R_FRV_GOTTLSDESCHI:
6206
        case R_FRV_GOTTLSDESCLO:
6207
        case R_FRV_GOTTLSOFF12:
6208
        case R_FRV_GOTTLSOFFHI:
6209
        case R_FRV_GOTTLSOFFLO:
6210
        case R_FRV_TLSOFF:
6211
        case R_FRV_GOT12:
6212
        case R_FRV_GOTHI:
6213
        case R_FRV_GOTLO:
6214
        case R_FRV_FUNCDESC_GOT12:
6215
        case R_FRV_FUNCDESC_GOTHI:
6216
        case R_FRV_FUNCDESC_GOTLO:
6217
        case R_FRV_GOTOFF12:
6218
        case R_FRV_GOTOFFHI:
6219
        case R_FRV_GOTOFFLO:
6220
        case R_FRV_FUNCDESC_GOTOFF12:
6221
        case R_FRV_FUNCDESC_GOTOFFHI:
6222
        case R_FRV_FUNCDESC_GOTOFFLO:
6223
        case R_FRV_FUNCDESC:
6224
        case R_FRV_FUNCDESC_VALUE:
6225
        case R_FRV_TLSMOFF12:
6226
        case R_FRV_TLSMOFFHI:
6227
        case R_FRV_TLSMOFFLO:
6228
        case R_FRV_TLSMOFF:
6229
          if (! IS_FDPIC (abfd))
6230
            goto bad_reloc;
6231
          /* Fall through.  */
6232
        case R_FRV_GPREL12:
6233
        case R_FRV_GPRELU12:
6234
        case R_FRV_GPRELHI:
6235
        case R_FRV_GPRELLO:
6236
        case R_FRV_LABEL24:
6237
        case R_FRV_32:
6238
          if (! dynobj)
6239
            {
6240
              elf_hash_table (info)->dynobj = dynobj = abfd;
6241
              if (! _frv_create_got_section (abfd, info))
6242
                return FALSE;
6243
            }
6244
          if (! IS_FDPIC (abfd))
6245
            {
6246
              picrel = NULL;
6247
              break;
6248
            }
6249
          if (h != NULL)
6250
            {
6251
              if (h->dynindx == -1)
6252
                switch (ELF_ST_VISIBILITY (h->other))
6253
                  {
6254
                  case STV_INTERNAL:
6255
                  case STV_HIDDEN:
6256
                    break;
6257
                  default:
6258
                    bfd_elf_link_record_dynamic_symbol (info, h);
6259
                    break;
6260
                  }
6261
              picrel
6262
                = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info),
6263
                                                   abfd, h,
6264
                                                   rel->r_addend, INSERT);
6265
            }
6266
          else
6267
            picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
6268
                                                     (info), abfd, r_symndx,
6269
                                                     rel->r_addend, INSERT);
6270
          if (! picrel)
6271
            return FALSE;
6272
          break;
6273
 
6274
        default:
6275
          picrel = NULL;
6276
          break;
6277
        }
6278
 
6279
      switch (ELF32_R_TYPE (rel->r_info))
6280
        {
6281
        case R_FRV_LABEL24:
6282
          if (IS_FDPIC (abfd))
6283
            picrel->call = 1;
6284
          break;
6285
 
6286
        case R_FRV_FUNCDESC_VALUE:
6287
          picrel->relocsfdv++;
6288
          if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
6289
            picrel->relocs32--;
6290
          /* Fall through.  */
6291
 
6292
        case R_FRV_32:
6293
          if (! IS_FDPIC (abfd))
6294
            break;
6295
 
6296
          picrel->sym = 1;
6297
          if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
6298
            picrel->relocs32++;
6299
          break;
6300
 
6301
        case R_FRV_GOT12:
6302
          picrel->got12 = 1;
6303
          break;
6304
 
6305
        case R_FRV_GOTHI:
6306
        case R_FRV_GOTLO:
6307
          picrel->gothilo = 1;
6308
          break;
6309
 
6310
        case R_FRV_FUNCDESC_GOT12:
6311
          picrel->fdgot12 = 1;
6312
          break;
6313
 
6314
        case R_FRV_FUNCDESC_GOTHI:
6315
        case R_FRV_FUNCDESC_GOTLO:
6316
          picrel->fdgothilo = 1;
6317
          break;
6318
 
6319
        case R_FRV_GOTOFF12:
6320
        case R_FRV_GOTOFFHI:
6321
        case R_FRV_GOTOFFLO:
6322
          picrel->gotoff = 1;
6323
          break;
6324
 
6325
        case R_FRV_FUNCDESC_GOTOFF12:
6326
          picrel->fdgoff12 = 1;
6327
          break;
6328
 
6329
        case R_FRV_FUNCDESC_GOTOFFHI:
6330
        case R_FRV_FUNCDESC_GOTOFFLO:
6331
          picrel->fdgoffhilo = 1;
6332
          break;
6333
 
6334
        case R_FRV_FUNCDESC:
6335
          picrel->fd = 1;
6336
          picrel->relocsfd++;
6337
          break;
6338
 
6339
        case R_FRV_GETTLSOFF:
6340
          picrel->tlsplt = 1;
6341
          break;
6342
 
6343
        case R_FRV_TLSDESC_VALUE:
6344
          picrel->relocstlsd++;
6345
          goto bad_reloc;
6346
 
6347
        case R_FRV_GOTTLSDESC12:
6348
          picrel->tlsdesc12 = 1;
6349
          break;
6350
 
6351
        case R_FRV_GOTTLSDESCHI:
6352
        case R_FRV_GOTTLSDESCLO:
6353
          picrel->tlsdeschilo = 1;
6354
          break;
6355
 
6356
        case R_FRV_TLSMOFF12:
6357
        case R_FRV_TLSMOFFHI:
6358
        case R_FRV_TLSMOFFLO:
6359
        case R_FRV_TLSMOFF:
6360
          break;
6361
 
6362
        case R_FRV_GOTTLSOFF12:
6363
          picrel->tlsoff12 = 1;
6364
          info->flags |= DF_STATIC_TLS;
6365
          break;
6366
 
6367
        case R_FRV_GOTTLSOFFHI:
6368
        case R_FRV_GOTTLSOFFLO:
6369
          picrel->tlsoffhilo = 1;
6370
          info->flags |= DF_STATIC_TLS;
6371
          break;
6372
 
6373
        case R_FRV_TLSOFF:
6374
          picrel->relocstlsoff++;
6375
          info->flags |= DF_STATIC_TLS;
6376
          goto bad_reloc;
6377
 
6378
        /* This relocation describes the C++ object vtable hierarchy.
6379
           Reconstruct it for later use during GC.  */
6380
        case R_FRV_GNU_VTINHERIT:
6381
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6382
            return FALSE;
6383
          break;
6384
 
6385
        /* This relocation describes which C++ vtable entries are actually
6386
           used.  Record for later use during GC.  */
6387
        case R_FRV_GNU_VTENTRY:
6388
          BFD_ASSERT (h != NULL);
6389
          if (h != NULL
6390
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6391
            return FALSE;
6392
          break;
6393
 
6394
        case R_FRV_LABEL16:
6395
        case R_FRV_LO16:
6396
        case R_FRV_HI16:
6397
        case R_FRV_GPREL12:
6398
        case R_FRV_GPRELU12:
6399
        case R_FRV_GPREL32:
6400
        case R_FRV_GPRELHI:
6401
        case R_FRV_GPRELLO:
6402
        case R_FRV_TLSDESC_RELAX:
6403
        case R_FRV_GETTLSOFF_RELAX:
6404
        case R_FRV_TLSOFF_RELAX:
6405
          break;
6406
 
6407
        default:
6408
        bad_reloc:
6409
          (*_bfd_error_handler)
6410
            (_("%B: unsupported relocation type %i"),
6411
             abfd, ELF32_R_TYPE (rel->r_info));
6412
          return FALSE;
6413
        }
6414
    }
6415
 
6416
  return TRUE;
6417
}
6418
 
6419
 
6420
/* Return the machine subcode from the ELF e_flags header.  */
6421
 
6422
static int
6423
elf32_frv_machine (abfd)
6424
     bfd *abfd;
6425
{
6426
  switch (elf_elfheader (abfd)->e_flags & EF_FRV_CPU_MASK)
6427
    {
6428
    default:                break;
6429
    case EF_FRV_CPU_FR550:  return bfd_mach_fr550;
6430
    case EF_FRV_CPU_FR500:  return bfd_mach_fr500;
6431
    case EF_FRV_CPU_FR450:  return bfd_mach_fr450;
6432
    case EF_FRV_CPU_FR405:  return bfd_mach_fr400;
6433
    case EF_FRV_CPU_FR400:  return bfd_mach_fr400;
6434
    case EF_FRV_CPU_FR300:  return bfd_mach_fr300;
6435
    case EF_FRV_CPU_SIMPLE: return bfd_mach_frvsimple;
6436
    case EF_FRV_CPU_TOMCAT: return bfd_mach_frvtomcat;
6437
    }
6438
 
6439
  return bfd_mach_frv;
6440
}
6441
 
6442
/* Set the right machine number for a FRV ELF file.  */
6443
 
6444
static bfd_boolean
6445
elf32_frv_object_p (abfd)
6446
     bfd *abfd;
6447
{
6448
  bfd_default_set_arch_mach (abfd, bfd_arch_frv, elf32_frv_machine (abfd));
6449
  return (((elf_elfheader (abfd)->e_flags & EF_FRV_FDPIC) != 0)
6450
          == (IS_FDPIC (abfd)));
6451
}
6452
 
6453
/* Function to set the ELF flag bits.  */
6454
 
6455
static bfd_boolean
6456
frv_elf_set_private_flags (abfd, flags)
6457
     bfd *abfd;
6458
     flagword flags;
6459
{
6460
  elf_elfheader (abfd)->e_flags = flags;
6461
  elf_flags_init (abfd) = TRUE;
6462
  return TRUE;
6463
}
6464
 
6465
/* Copy backend specific data from one object module to another.  */
6466
 
6467
static bfd_boolean
6468
frv_elf_copy_private_bfd_data (ibfd, obfd)
6469
     bfd *ibfd;
6470
     bfd *obfd;
6471
{
6472
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6473
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6474
    return TRUE;
6475
 
6476
  BFD_ASSERT (!elf_flags_init (obfd)
6477
              || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
6478
 
6479
  elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6480
  elf_flags_init (obfd) = TRUE;
6481
 
6482
  /* Copy object attributes.  */
6483
  _bfd_elf_copy_obj_attributes (ibfd, obfd);
6484
 
6485
  return TRUE;
6486
}
6487
 
6488
/* Return true if the architecture described by elf header flag
6489
   EXTENSION is an extension of the architecture described by BASE.  */
6490
 
6491
static bfd_boolean
6492
frv_elf_arch_extension_p (flagword base, flagword extension)
6493
{
6494
  if (base == extension)
6495
    return TRUE;
6496
 
6497
  /* CPU_GENERIC code can be merged with code for a specific
6498
     architecture, in which case the result is marked as being
6499
     for the specific architecture.  Everything is therefore
6500
     an extension of CPU_GENERIC.  */
6501
  if (base == EF_FRV_CPU_GENERIC)
6502
    return TRUE;
6503
 
6504
  if (extension == EF_FRV_CPU_FR450)
6505
    if (base == EF_FRV_CPU_FR400 || base == EF_FRV_CPU_FR405)
6506
      return TRUE;
6507
 
6508
  if (extension == EF_FRV_CPU_FR405)
6509
    if (base == EF_FRV_CPU_FR400)
6510
      return TRUE;
6511
 
6512
  return FALSE;
6513
}
6514
 
6515
static bfd_boolean
6516
elf32_frvfdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
6517
{
6518
  unsigned i;
6519
 
6520
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6521
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6522
    return TRUE;
6523
 
6524
  if (! frv_elf_copy_private_bfd_data (ibfd, obfd))
6525
    return FALSE;
6526
 
6527
  if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
6528
      || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
6529
    return TRUE;
6530
 
6531
  /* Copy the stack size.  */
6532
  for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
6533
    if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
6534
      {
6535
        Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
6536
 
6537
        for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
6538
          if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
6539
            {
6540
              memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
6541
 
6542
              /* Rewrite the phdrs, since we're only called after they
6543
                 were first written.  */
6544
              if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
6545
                            ->s->sizeof_ehdr, SEEK_SET) != 0
6546
                  || get_elf_backend_data (obfd)->s
6547
                  ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
6548
                                     elf_elfheader (obfd)->e_phnum) != 0)
6549
                return FALSE;
6550
              break;
6551
            }
6552
 
6553
        break;
6554
      }
6555
 
6556
  return TRUE;
6557
}
6558
 
6559
/* Merge backend specific data from an object file to the output
6560
   object file when linking.  */
6561
 
6562
static bfd_boolean
6563
frv_elf_merge_private_bfd_data (ibfd, obfd)
6564
     bfd *ibfd;
6565
     bfd *obfd;
6566
{
6567
  flagword old_flags, old_partial;
6568
  flagword new_flags, new_partial;
6569
  bfd_boolean error = FALSE;
6570
  char new_opt[80];
6571
  char old_opt[80];
6572
 
6573
  new_opt[0] = old_opt[0] = '\0';
6574
  new_flags = elf_elfheader (ibfd)->e_flags;
6575
  old_flags = elf_elfheader (obfd)->e_flags;
6576
 
6577
  if (new_flags & EF_FRV_FDPIC)
6578
    new_flags &= ~EF_FRV_PIC;
6579
 
6580
#ifdef DEBUG
6581
  (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
6582
                         old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
6583
                         bfd_get_filename (ibfd));
6584
#endif
6585
 
6586
  if (!elf_flags_init (obfd))                   /* First call, no flags set.  */
6587
    {
6588
      elf_flags_init (obfd) = TRUE;
6589
      old_flags = new_flags;
6590
    }
6591
 
6592
  else if (new_flags == old_flags)              /* Compatible flags are ok.  */
6593
    ;
6594
 
6595
  else                                          /* Possibly incompatible flags.  */
6596
    {
6597
      /* Warn if different # of gprs are used.  Note, 0 means nothing is
6598
         said about the size of gprs.  */
6599
      new_partial = (new_flags & EF_FRV_GPR_MASK);
6600
      old_partial = (old_flags & EF_FRV_GPR_MASK);
6601
      if (new_partial == old_partial)
6602
        ;
6603
 
6604
      else if (new_partial == 0)
6605
        ;
6606
 
6607
      else if (old_partial == 0)
6608
        old_flags |= new_partial;
6609
 
6610
      else
6611
        {
6612
          switch (new_partial)
6613
            {
6614
            default:            strcat (new_opt, " -mgpr-??"); break;
6615
            case EF_FRV_GPR_32: strcat (new_opt, " -mgpr-32"); break;
6616
            case EF_FRV_GPR_64: strcat (new_opt, " -mgpr-64"); break;
6617
            }
6618
 
6619
          switch (old_partial)
6620
            {
6621
            default:            strcat (old_opt, " -mgpr-??"); break;
6622
            case EF_FRV_GPR_32: strcat (old_opt, " -mgpr-32"); break;
6623
            case EF_FRV_GPR_64: strcat (old_opt, " -mgpr-64"); break;
6624
            }
6625
        }
6626
 
6627
      /* Warn if different # of fprs are used.  Note, 0 means nothing is
6628
         said about the size of fprs.  */
6629
      new_partial = (new_flags & EF_FRV_FPR_MASK);
6630
      old_partial = (old_flags & EF_FRV_FPR_MASK);
6631
      if (new_partial == old_partial)
6632
        ;
6633
 
6634
      else if (new_partial == 0)
6635
        ;
6636
 
6637
      else if (old_partial == 0)
6638
        old_flags |= new_partial;
6639
 
6640
      else
6641
        {
6642
          switch (new_partial)
6643
            {
6644
            default:              strcat (new_opt, " -mfpr-?");      break;
6645
            case EF_FRV_FPR_32:   strcat (new_opt, " -mfpr-32");     break;
6646
            case EF_FRV_FPR_64:   strcat (new_opt, " -mfpr-64");     break;
6647
            case EF_FRV_FPR_NONE: strcat (new_opt, " -msoft-float"); break;
6648
            }
6649
 
6650
          switch (old_partial)
6651
            {
6652
            default:              strcat (old_opt, " -mfpr-?");      break;
6653
            case EF_FRV_FPR_32:   strcat (old_opt, " -mfpr-32");     break;
6654
            case EF_FRV_FPR_64:   strcat (old_opt, " -mfpr-64");     break;
6655
            case EF_FRV_FPR_NONE: strcat (old_opt, " -msoft-float"); break;
6656
            }
6657
        }
6658
 
6659
      /* Warn if different dword support was used.  Note, 0 means nothing is
6660
         said about the dword support.  */
6661
      new_partial = (new_flags & EF_FRV_DWORD_MASK);
6662
      old_partial = (old_flags & EF_FRV_DWORD_MASK);
6663
      if (new_partial == old_partial)
6664
        ;
6665
 
6666
      else if (new_partial == 0)
6667
        ;
6668
 
6669
      else if (old_partial == 0)
6670
        old_flags |= new_partial;
6671
 
6672
      else
6673
        {
6674
          switch (new_partial)
6675
            {
6676
            default:               strcat (new_opt, " -mdword-?");  break;
6677
            case EF_FRV_DWORD_YES: strcat (new_opt, " -mdword");    break;
6678
            case EF_FRV_DWORD_NO:  strcat (new_opt, " -mno-dword"); break;
6679
            }
6680
 
6681
          switch (old_partial)
6682
            {
6683
            default:               strcat (old_opt, " -mdword-?");  break;
6684
            case EF_FRV_DWORD_YES: strcat (old_opt, " -mdword");    break;
6685
            case EF_FRV_DWORD_NO:  strcat (old_opt, " -mno-dword"); break;
6686
            }
6687
        }
6688
 
6689
      /* Or in flags that accumulate (ie, if one module uses it, mark that the
6690
         feature is used.  */
6691
      old_flags |= new_flags & (EF_FRV_DOUBLE
6692
                                | EF_FRV_MEDIA
6693
                                | EF_FRV_MULADD
6694
                                | EF_FRV_NON_PIC_RELOCS);
6695
 
6696
      /* If any module was compiled without -G0, clear the G0 bit.  */
6697
      old_flags = ((old_flags & ~ EF_FRV_G0)
6698
                   | (old_flags & new_flags & EF_FRV_G0));
6699
 
6700
      /* If any module was compiled without -mnopack, clear the mnopack bit.  */
6701
      old_flags = ((old_flags & ~ EF_FRV_NOPACK)
6702
                   | (old_flags & new_flags & EF_FRV_NOPACK));
6703
 
6704
      /* We don't have to do anything if the pic flags are the same, or the new
6705
         module(s) were compiled with -mlibrary-pic.  */
6706
      new_partial = (new_flags & EF_FRV_PIC_FLAGS);
6707
      old_partial = (old_flags & EF_FRV_PIC_FLAGS);
6708
      if ((new_partial == old_partial) || ((new_partial & EF_FRV_LIBPIC) != 0))
6709
        ;
6710
 
6711
      /* If the old module(s) were compiled with -mlibrary-pic, copy in the pic
6712
         flags if any from the new module.  */
6713
      else if ((old_partial & EF_FRV_LIBPIC) != 0)
6714
        old_flags = (old_flags & ~ EF_FRV_PIC_FLAGS) | new_partial;
6715
 
6716
      /* If we have mixtures of -fpic and -fPIC, or in both bits.  */
6717
      else if (new_partial != 0 && old_partial != 0)
6718
        old_flags |= new_partial;
6719
 
6720
      /* One module was compiled for pic and the other was not, see if we have
6721
         had any relocations that are not pic-safe.  */
6722
      else
6723
        {
6724
          if ((old_flags & EF_FRV_NON_PIC_RELOCS) == 0)
6725
            old_flags |= new_partial;
6726
          else
6727
            {
6728
              old_flags &= ~ EF_FRV_PIC_FLAGS;
6729
#ifndef FRV_NO_PIC_ERROR
6730
              error = TRUE;
6731
              (*_bfd_error_handler)
6732
                (_("%s: compiled with %s and linked with modules that use non-pic relocations"),
6733
                 bfd_get_filename (ibfd),
6734
                 (new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
6735
#endif
6736
            }
6737
        }
6738
 
6739
      /* Warn if different cpu is used (allow a specific cpu to override
6740
         the generic cpu).  */
6741
      new_partial = (new_flags & EF_FRV_CPU_MASK);
6742
      old_partial = (old_flags & EF_FRV_CPU_MASK);
6743
      if (frv_elf_arch_extension_p (new_partial, old_partial))
6744
        ;
6745
 
6746
      else if (frv_elf_arch_extension_p (old_partial, new_partial))
6747
        old_flags = (old_flags & ~EF_FRV_CPU_MASK) | new_partial;
6748
 
6749
      else
6750
        {
6751
          switch (new_partial)
6752
            {
6753
            default:                 strcat (new_opt, " -mcpu=?");      break;
6754
            case EF_FRV_CPU_GENERIC: strcat (new_opt, " -mcpu=frv");    break;
6755
            case EF_FRV_CPU_SIMPLE:  strcat (new_opt, " -mcpu=simple"); break;
6756
            case EF_FRV_CPU_FR550:   strcat (new_opt, " -mcpu=fr550");  break;
6757
            case EF_FRV_CPU_FR500:   strcat (new_opt, " -mcpu=fr500");  break;
6758
            case EF_FRV_CPU_FR450:   strcat (new_opt, " -mcpu=fr450");  break;
6759
            case EF_FRV_CPU_FR405:   strcat (new_opt, " -mcpu=fr405");  break;
6760
            case EF_FRV_CPU_FR400:   strcat (new_opt, " -mcpu=fr400");  break;
6761
            case EF_FRV_CPU_FR300:   strcat (new_opt, " -mcpu=fr300");  break;
6762
            case EF_FRV_CPU_TOMCAT:  strcat (new_opt, " -mcpu=tomcat"); break;
6763
            }
6764
 
6765
          switch (old_partial)
6766
            {
6767
            default:                 strcat (old_opt, " -mcpu=?");      break;
6768
            case EF_FRV_CPU_GENERIC: strcat (old_opt, " -mcpu=frv");    break;
6769
            case EF_FRV_CPU_SIMPLE:  strcat (old_opt, " -mcpu=simple"); break;
6770
            case EF_FRV_CPU_FR550:   strcat (old_opt, " -mcpu=fr550");  break;
6771
            case EF_FRV_CPU_FR500:   strcat (old_opt, " -mcpu=fr500");  break;
6772
            case EF_FRV_CPU_FR450:   strcat (old_opt, " -mcpu=fr450");  break;
6773
            case EF_FRV_CPU_FR405:   strcat (old_opt, " -mcpu=fr405");  break;
6774
            case EF_FRV_CPU_FR400:   strcat (old_opt, " -mcpu=fr400");  break;
6775
            case EF_FRV_CPU_FR300:   strcat (old_opt, " -mcpu=fr300");  break;
6776
            case EF_FRV_CPU_TOMCAT:  strcat (old_opt, " -mcpu=tomcat"); break;
6777
            }
6778
        }
6779
 
6780
      /* Print out any mismatches from above.  */
6781
      if (new_opt[0])
6782
        {
6783
          error = TRUE;
6784
          (*_bfd_error_handler)
6785
            (_("%s: compiled with %s and linked with modules compiled with %s"),
6786
             bfd_get_filename (ibfd), new_opt, old_opt);
6787
        }
6788
 
6789
      /* Warn about any other mismatches */
6790
      new_partial = (new_flags & ~ EF_FRV_ALL_FLAGS);
6791
      old_partial = (old_flags & ~ EF_FRV_ALL_FLAGS);
6792
      if (new_partial != old_partial)
6793
        {
6794
          old_flags |= new_partial;
6795
          error = TRUE;
6796
          (*_bfd_error_handler)
6797
            (_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),
6798
             bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);
6799
        }
6800
    }
6801
 
6802
  /* If the cpu is -mcpu=simple, then set the -mnopack bit.  */
6803
  if ((old_flags & EF_FRV_CPU_MASK) == EF_FRV_CPU_SIMPLE)
6804
    old_flags |= EF_FRV_NOPACK;
6805
 
6806
  /* Update the old flags now with changes made above.  */
6807
  old_partial = elf_elfheader (obfd)->e_flags & EF_FRV_CPU_MASK;
6808
  elf_elfheader (obfd)->e_flags = old_flags;
6809
  if (old_partial != (old_flags & EF_FRV_CPU_MASK))
6810
    bfd_default_set_arch_mach (obfd, bfd_arch_frv, elf32_frv_machine (obfd));
6811
 
6812
  if (((new_flags & EF_FRV_FDPIC) == 0)
6813
      != (! IS_FDPIC (ibfd)))
6814
    {
6815
      error = TRUE;
6816
      if (IS_FDPIC (obfd))
6817
        (*_bfd_error_handler)
6818
          (_("%s: cannot link non-fdpic object file into fdpic executable"),
6819
           bfd_get_filename (ibfd));
6820
      else
6821
        (*_bfd_error_handler)
6822
          (_("%s: cannot link fdpic object file into non-fdpic executable"),
6823
           bfd_get_filename (ibfd));
6824
    }
6825
 
6826
  if (error)
6827
    bfd_set_error (bfd_error_bad_value);
6828
 
6829
  return !error;
6830
}
6831
 
6832
 
6833
bfd_boolean
6834
frv_elf_print_private_bfd_data (abfd, ptr)
6835
     bfd *abfd;
6836
     PTR ptr;
6837
{
6838
  FILE *file = (FILE *) ptr;
6839
  flagword flags;
6840
 
6841
  BFD_ASSERT (abfd != NULL && ptr != NULL);
6842
 
6843
  /* Print normal ELF private data.  */
6844
  _bfd_elf_print_private_bfd_data (abfd, ptr);
6845
 
6846
  flags = elf_elfheader (abfd)->e_flags;
6847
  fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
6848
 
6849
  switch (flags & EF_FRV_CPU_MASK)
6850
    {
6851
    default:                                                    break;
6852
    case EF_FRV_CPU_SIMPLE: fprintf (file, " -mcpu=simple");    break;
6853
    case EF_FRV_CPU_FR550:  fprintf (file, " -mcpu=fr550");     break;
6854
    case EF_FRV_CPU_FR500:  fprintf (file, " -mcpu=fr500");     break;
6855
    case EF_FRV_CPU_FR450:  fprintf (file, " -mcpu=fr450");     break;
6856
    case EF_FRV_CPU_FR405:  fprintf (file, " -mcpu=fr405");     break;
6857
    case EF_FRV_CPU_FR400:  fprintf (file, " -mcpu=fr400");     break;
6858
    case EF_FRV_CPU_FR300:  fprintf (file, " -mcpu=fr300");     break;
6859
    case EF_FRV_CPU_TOMCAT: fprintf (file, " -mcpu=tomcat");    break;
6860
    }
6861
 
6862
  switch (flags & EF_FRV_GPR_MASK)
6863
    {
6864
    default:                                                    break;
6865
    case EF_FRV_GPR_32: fprintf (file, " -mgpr-32");            break;
6866
    case EF_FRV_GPR_64: fprintf (file, " -mgpr-64");            break;
6867
    }
6868
 
6869
  switch (flags & EF_FRV_FPR_MASK)
6870
    {
6871
    default:                                                    break;
6872
    case EF_FRV_FPR_32:   fprintf (file, " -mfpr-32");          break;
6873
    case EF_FRV_FPR_64:   fprintf (file, " -mfpr-64");          break;
6874
    case EF_FRV_FPR_NONE: fprintf (file, " -msoft-float");      break;
6875
    }
6876
 
6877
  switch (flags & EF_FRV_DWORD_MASK)
6878
    {
6879
    default:                                                    break;
6880
    case EF_FRV_DWORD_YES: fprintf (file, " -mdword");          break;
6881
    case EF_FRV_DWORD_NO:  fprintf (file, " -mno-dword");       break;
6882
    }
6883
 
6884
  if (flags & EF_FRV_DOUBLE)
6885
    fprintf (file, " -mdouble");
6886
 
6887
  if (flags & EF_FRV_MEDIA)
6888
    fprintf (file, " -mmedia");
6889
 
6890
  if (flags & EF_FRV_MULADD)
6891
    fprintf (file, " -mmuladd");
6892
 
6893
  if (flags & EF_FRV_PIC)
6894
    fprintf (file, " -fpic");
6895
 
6896
  if (flags & EF_FRV_BIGPIC)
6897
    fprintf (file, " -fPIC");
6898
 
6899
  if (flags & EF_FRV_LIBPIC)
6900
    fprintf (file, " -mlibrary-pic");
6901
 
6902
  if (flags & EF_FRV_FDPIC)
6903
    fprintf (file, " -mfdpic");
6904
 
6905
  if (flags & EF_FRV_NON_PIC_RELOCS)
6906
    fprintf (file, " non-pic relocations");
6907
 
6908
  if (flags & EF_FRV_G0)
6909
    fprintf (file, " -G0");
6910
 
6911
  fputc ('\n', file);
6912
  return TRUE;
6913
}
6914
 
6915
 
6916
/* Support for core dump NOTE sections.  */
6917
 
6918
static bfd_boolean
6919
elf32_frv_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
6920
{
6921
  int offset;
6922
  unsigned int raw_size;
6923
 
6924
  switch (note->descsz)
6925
    {
6926
      default:
6927
        return FALSE;
6928
 
6929
      /* The Linux/FRV elf_prstatus struct is 268 bytes long.  The other
6930
         hardcoded offsets and sizes listed below (and contained within
6931
         this lexical block) refer to fields in the target's elf_prstatus
6932
         struct.  */
6933
      case 268:
6934
        /* `pr_cursig' is at offset 12.  */
6935
        elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
6936
 
6937
        /* `pr_pid' is at offset 24.  */
6938
        elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
6939
 
6940
        /* `pr_reg' is at offset 72.  */
6941
        offset = 72;
6942
 
6943
        /* Most grok_prstatus implementations set `raw_size' to the size
6944
           of the pr_reg field.  For Linux/FRV, we set `raw_size' to be
6945
           the size of `pr_reg' plus the size of `pr_exec_fdpic_loadmap'
6946
           and `pr_interp_fdpic_loadmap', both of which (by design)
6947
           immediately follow `pr_reg'.  This will allow these fields to
6948
           be viewed by GDB as registers.
6949
 
6950
           `pr_reg' is 184 bytes long.  `pr_exec_fdpic_loadmap' and
6951
           `pr_interp_fdpic_loadmap' are 4 bytes each.  */
6952
        raw_size = 184 + 4 + 4;
6953
 
6954
        break;
6955
    }
6956
 
6957
  /* Make a ".reg/999" section.  */
6958
  return _bfd_elfcore_make_pseudosection (abfd, ".reg", raw_size,
6959
                                          note->descpos + offset);
6960
}
6961
 
6962
static bfd_boolean
6963
elf32_frv_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
6964
{
6965
  switch (note->descsz)
6966
    {
6967
      default:
6968
        return FALSE;
6969
 
6970
      /* The Linux/FRV elf_prpsinfo struct is 124 bytes long.  */
6971
      case 124:
6972
 
6973
        /* `pr_fname' is found at offset 28 and is 16 bytes long.  */
6974
        elf_tdata (abfd)->core_program
6975
          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
6976
 
6977
        /* `pr_psargs' is found at offset 44 and is 80 bytes long.  */
6978
        elf_tdata (abfd)->core_command
6979
          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
6980
    }
6981
 
6982
  /* Note that for some reason, a spurious space is tacked
6983
     onto the end of the args in some (at least one anyway)
6984
     implementations, so strip it off if it exists.  */
6985
 
6986
  {
6987
    char *command = elf_tdata (abfd)->core_command;
6988
    int n = strlen (command);
6989
 
6990
    if (0 < n && command[n - 1] == ' ')
6991
      command[n - 1] = '\0';
6992
  }
6993
 
6994
  return TRUE;
6995
}
6996
#define ELF_ARCH                bfd_arch_frv
6997
#define ELF_MACHINE_CODE        EM_CYGNUS_FRV
6998
#define ELF_MAXPAGESIZE         0x1000
6999
 
7000
#define TARGET_BIG_SYM          bfd_elf32_frv_vec
7001
#define TARGET_BIG_NAME         "elf32-frv"
7002
 
7003
#define elf_info_to_howto                       frv_info_to_howto_rela
7004
#define elf_backend_relocate_section            elf32_frv_relocate_section
7005
#define elf_backend_gc_mark_hook                elf32_frv_gc_mark_hook
7006
#define elf_backend_check_relocs                elf32_frv_check_relocs
7007
#define elf_backend_object_p                    elf32_frv_object_p
7008
#define elf_backend_add_symbol_hook             elf32_frv_add_symbol_hook
7009
 
7010
#define elf_backend_can_gc_sections             1
7011
#define elf_backend_rela_normal                 1
7012
 
7013
#define bfd_elf32_bfd_reloc_type_lookup         frv_reloc_type_lookup
7014
#define bfd_elf32_bfd_reloc_name_lookup frv_reloc_name_lookup
7015
#define bfd_elf32_bfd_set_private_flags         frv_elf_set_private_flags
7016
#define bfd_elf32_bfd_copy_private_bfd_data     frv_elf_copy_private_bfd_data
7017
#define bfd_elf32_bfd_merge_private_bfd_data    frv_elf_merge_private_bfd_data
7018
#define bfd_elf32_bfd_print_private_bfd_data    frv_elf_print_private_bfd_data
7019
 
7020
#define elf_backend_want_got_sym        1
7021
#define elf_backend_got_header_size     0
7022
#define elf_backend_want_got_plt        0
7023
#define elf_backend_plt_readonly        1
7024
#define elf_backend_want_plt_sym        0
7025
#define elf_backend_plt_header_size     0
7026
 
7027
#define elf_backend_finish_dynamic_sections \
7028
                elf32_frv_finish_dynamic_sections
7029
 
7030
#define elf_backend_grok_prstatus       elf32_frv_grok_prstatus
7031
#define elf_backend_grok_psinfo         elf32_frv_grok_psinfo
7032
 
7033
#include "elf32-target.h"
7034
 
7035
#undef ELF_MAXPAGESIZE
7036
#define ELF_MAXPAGESIZE         0x4000
7037
 
7038
#undef TARGET_BIG_SYM
7039
#define TARGET_BIG_SYM          bfd_elf32_frvfdpic_vec
7040
#undef TARGET_BIG_NAME
7041
#define TARGET_BIG_NAME         "elf32-frvfdpic"
7042
#undef  elf32_bed
7043
#define elf32_bed               elf32_frvfdpic_bed
7044
 
7045
#undef elf_info_to_howto_rel
7046
#define elf_info_to_howto_rel   frvfdpic_info_to_howto_rel
7047
 
7048
#undef bfd_elf32_bfd_link_hash_table_create
7049
#define bfd_elf32_bfd_link_hash_table_create \
7050
                frvfdpic_elf_link_hash_table_create
7051
#undef elf_backend_always_size_sections
7052
#define elf_backend_always_size_sections \
7053
                elf32_frvfdpic_always_size_sections
7054
#undef elf_backend_modify_program_headers
7055
#define elf_backend_modify_program_headers \
7056
                elf32_frvfdpic_modify_program_headers
7057
#undef bfd_elf32_bfd_copy_private_bfd_data
7058
#define bfd_elf32_bfd_copy_private_bfd_data \
7059
                elf32_frvfdpic_copy_private_bfd_data
7060
 
7061
#undef elf_backend_create_dynamic_sections
7062
#define elf_backend_create_dynamic_sections \
7063
                elf32_frvfdpic_create_dynamic_sections
7064
#undef elf_backend_adjust_dynamic_symbol
7065
#define elf_backend_adjust_dynamic_symbol \
7066
                elf32_frvfdpic_adjust_dynamic_symbol
7067
#undef elf_backend_size_dynamic_sections
7068
#define elf_backend_size_dynamic_sections \
7069
                elf32_frvfdpic_size_dynamic_sections
7070
#undef bfd_elf32_bfd_relax_section
7071
#define bfd_elf32_bfd_relax_section \
7072
  elf32_frvfdpic_relax_section
7073
#undef elf_backend_finish_dynamic_symbol
7074
#define elf_backend_finish_dynamic_symbol \
7075
                elf32_frvfdpic_finish_dynamic_symbol
7076
#undef elf_backend_finish_dynamic_sections
7077
#define elf_backend_finish_dynamic_sections \
7078
                elf32_frvfdpic_finish_dynamic_sections
7079
 
7080
#undef elf_backend_discard_info
7081
#define elf_backend_discard_info \
7082
                frvfdpic_elf_discard_info
7083
#undef elf_backend_can_make_relative_eh_frame
7084
#define elf_backend_can_make_relative_eh_frame \
7085
                frvfdpic_elf_use_relative_eh_frame
7086
#undef elf_backend_can_make_lsda_relative_eh_frame
7087
#define elf_backend_can_make_lsda_relative_eh_frame \
7088
                frvfdpic_elf_use_relative_eh_frame
7089
#undef elf_backend_encode_eh_address
7090
#define elf_backend_encode_eh_address \
7091
                frvfdpic_elf_encode_eh_address
7092
 
7093
#undef elf_backend_may_use_rel_p
7094
#define elf_backend_may_use_rel_p       1
7095
#undef elf_backend_may_use_rela_p
7096
#define elf_backend_may_use_rela_p      1
7097
/* We use REL for dynamic relocations only.  */
7098
#undef elf_backend_default_use_rela_p
7099
#define elf_backend_default_use_rela_p  1
7100
 
7101
#undef elf_backend_omit_section_dynsym
7102
#define elf_backend_omit_section_dynsym _frvfdpic_link_omit_section_dynsym
7103
 
7104
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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