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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [elf32-frv.c] - Blame information for rev 14

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 14 khays
/* FRV-specific support for 32-bit ELF.
2
   Copyright 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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;
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
          if (name == NULL || name[0] == 0)
2800
            name = bfd_section_name (input_bfd, sec);
2801
        }
2802
      else
2803
        {
2804
          bfd_boolean warned;
2805
          bfd_boolean unresolved_reloc;
2806
 
2807
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2808
                                   r_symndx, symtab_hdr, sym_hashes,
2809
                                   h, sec, relocation,
2810
                                   unresolved_reloc, warned);
2811
          osec = sec;
2812
          name = h->root.root.string;
2813
        }
2814
 
2815
      if (sec != NULL && elf_discarded_section (sec))
2816
        RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2817
                                         rel, relend, howto, contents);
2818
 
2819
      if (info->relocatable)
2820
        continue;
2821
 
2822
      if (r_type != R_FRV_TLSMOFF
2823
          && h != NULL
2824
          && (h->root.type == bfd_link_hash_defined
2825
              || h->root.type == bfd_link_hash_defweak)
2826
          && !FRVFDPIC_SYM_LOCAL (info, h))
2827
        {
2828
          osec = sec = NULL;
2829
          relocation = 0;
2830
        }
2831
 
2832
      switch (r_type)
2833
        {
2834
        case R_FRV_LABEL24:
2835
        case R_FRV_32:
2836
          if (! IS_FDPIC (output_bfd))
2837
            goto non_fdpic;
2838
 
2839
        case R_FRV_GOT12:
2840
        case R_FRV_GOTHI:
2841
        case R_FRV_GOTLO:
2842
        case R_FRV_FUNCDESC_GOT12:
2843
        case R_FRV_FUNCDESC_GOTHI:
2844
        case R_FRV_FUNCDESC_GOTLO:
2845
        case R_FRV_GOTOFF12:
2846
        case R_FRV_GOTOFFHI:
2847
        case R_FRV_GOTOFFLO:
2848
        case R_FRV_FUNCDESC_GOTOFF12:
2849
        case R_FRV_FUNCDESC_GOTOFFHI:
2850
        case R_FRV_FUNCDESC_GOTOFFLO:
2851
        case R_FRV_FUNCDESC:
2852
        case R_FRV_FUNCDESC_VALUE:
2853
        case R_FRV_GETTLSOFF:
2854
        case R_FRV_TLSDESC_VALUE:
2855
        case R_FRV_GOTTLSDESC12:
2856
        case R_FRV_GOTTLSDESCHI:
2857
        case R_FRV_GOTTLSDESCLO:
2858
        case R_FRV_TLSMOFF12:
2859
        case R_FRV_TLSMOFFHI:
2860
        case R_FRV_TLSMOFFLO:
2861
        case R_FRV_GOTTLSOFF12:
2862
        case R_FRV_GOTTLSOFFHI:
2863
        case R_FRV_GOTTLSOFFLO:
2864
        case R_FRV_TLSOFF:
2865
        case R_FRV_TLSDESC_RELAX:
2866
        case R_FRV_GETTLSOFF_RELAX:
2867
        case R_FRV_TLSOFF_RELAX:
2868
        case R_FRV_TLSMOFF:
2869
          if (h != NULL)
2870
            picrel = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info
2871
                                                      (info), input_bfd, h,
2872
                                                      orig_addend, INSERT);
2873
          else
2874
            /* In order to find the entry we created before, we must
2875
               use the original addend, not the one that may have been
2876
               modified by _bfd_elf_rela_local_sym().  */
2877
            picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
2878
                                                     (info), input_bfd, r_symndx,
2879
                                                     orig_addend, INSERT);
2880
          if (! picrel)
2881
            return FALSE;
2882
 
2883
          if (!_frvfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info,
2884
                                                      osec, sym,
2885
                                                      rel->r_addend))
2886
            {
2887
              info->callbacks->einfo
2888
                (_("%H: relocation to `%s+%v'"
2889
                   " may have caused the error above\n"),
2890
                 input_bfd, input_section, rel->r_offset, name, rel->r_addend);
2891
              return FALSE;
2892
            }
2893
 
2894
          break;
2895
 
2896
        default:
2897
        non_fdpic:
2898
          picrel = NULL;
2899
          if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
2900
            {
2901
              info->callbacks->einfo
2902
                (_("%H: relocation references symbol"
2903
                   " not defined in the module\n"),
2904
                 input_bfd, input_section, rel->r_offset);
2905
              return FALSE;
2906
            }
2907
          break;
2908
        }
2909
 
2910
      switch (r_type)
2911
        {
2912
        case R_FRV_GETTLSOFF:
2913
        case R_FRV_TLSDESC_VALUE:
2914
        case R_FRV_GOTTLSDESC12:
2915
        case R_FRV_GOTTLSDESCHI:
2916
        case R_FRV_GOTTLSDESCLO:
2917
        case R_FRV_TLSMOFF12:
2918
        case R_FRV_TLSMOFFHI:
2919
        case R_FRV_TLSMOFFLO:
2920
        case R_FRV_GOTTLSOFF12:
2921
        case R_FRV_GOTTLSOFFHI:
2922
        case R_FRV_GOTTLSOFFLO:
2923
        case R_FRV_TLSOFF:
2924
        case R_FRV_TLSDESC_RELAX:
2925
        case R_FRV_GETTLSOFF_RELAX:
2926
        case R_FRV_TLSOFF_RELAX:
2927
        case R_FRV_TLSMOFF:
2928
          if (sec && (bfd_is_abs_section (sec) || bfd_is_und_section (sec)))
2929
            relocation += tls_biased_base (info);
2930
          break;
2931
 
2932
        default:
2933
          break;
2934
        }
2935
 
2936
      /* Try to apply TLS relaxations.  */
2937
      if (1)
2938
        switch (r_type)
2939
          {
2940
 
2941
#define LOCAL_EXEC_P(info, picrel) \
2942
  ((info)->executable \
2943
   && (picrel->symndx != -1 || FRVFDPIC_SYM_LOCAL ((info), (picrel)->d.h)))
2944
#define INITIAL_EXEC_P(info, picrel) \
2945
  (((info)->executable || (info)->flags & DF_STATIC_TLS) \
2946
   && (picrel)->tlsoff_entry)
2947
 
2948
#define IN_RANGE_FOR_OFST12_P(value) \
2949
  ((bfd_vma)((value) + 2048) < (bfd_vma)4096)
2950
#define IN_RANGE_FOR_SETLOS_P(value) \
2951
  ((bfd_vma)((value) + 32768) < (bfd_vma)65536)
2952
#define TLSMOFF_IN_RANGE_FOR_SETLOS_P(value, info) \
2953
  (IN_RANGE_FOR_SETLOS_P ((value) - tls_biased_base (info)))
2954
 
2955
#define RELAX_GETTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2956
  (LOCAL_EXEC_P ((info), (picrel)) \
2957
   && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2958
#define RELAX_GETTLSOFF_INITIAL_EXEC_P(info, picrel) \
2959
  (INITIAL_EXEC_P ((info), (picrel)) \
2960
   && IN_RANGE_FOR_OFST12_P ((picrel)->tlsoff_entry))
2961
 
2962
#define RELAX_TLSDESC_LOCAL_EXEC_P(info, picrel, value) \
2963
  (LOCAL_EXEC_P ((info), (picrel)))
2964
#define RELAX_TLSDESC_INITIAL_EXEC_P(info, picrel) \
2965
  (INITIAL_EXEC_P ((info), (picrel)))
2966
 
2967
#define RELAX_GOTTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2968
  (LOCAL_EXEC_P ((info), (picrel)) \
2969
   && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2970
 
2971
          case R_FRV_GETTLSOFF:
2972
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2973
 
2974
            /* Is this a call instruction?  */
2975
            if ((insn & (unsigned long)0x01fc0000) != 0x003c0000)
2976
              {
2977
                info->callbacks->einfo
2978
                  (_("%H: R_FRV_GETTLSOFF not applied to a call instruction\n"),
2979
                   input_bfd, input_section, rel->r_offset);
2980
                return FALSE;
2981
              }
2982
 
2983
            if (RELAX_GETTLSOFF_LOCAL_EXEC_P (info, picrel,
2984
                                              relocation + rel->r_addend))
2985
              {
2986
                /* Replace the call instruction (except the packing bit)
2987
                   with setlos #tlsmofflo(symbol+offset), gr9.  */
2988
                insn &= (unsigned long)0x80000000;
2989
                insn |= (unsigned long)0x12fc0000;
2990
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2991
 
2992
                r_type = R_FRV_TLSMOFFLO;
2993
                howto  = elf32_frv_howto_table + r_type;
2994
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
2995
              }
2996
 
2997
            else if (RELAX_GETTLSOFF_INITIAL_EXEC_P (info, picrel))
2998
              {
2999
                /* Replace the call instruction (except the packing bit)
3000
                   with ldi @(gr15, #gottlsoff12(symbol+addend)), gr9.  */
3001
                insn &= (unsigned long)0x80000000;
3002
                insn |= (unsigned long)0x12c8f000;
3003
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3004
 
3005
                r_type = R_FRV_GOTTLSOFF12;
3006
                howto  = elf32_frv_howto_table + r_type;
3007
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3008
              }
3009
 
3010
            break;
3011
 
3012
          case R_FRV_GOTTLSDESC12:
3013
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3014
 
3015
            /* Is this an lddi instruction?  */
3016
            if ((insn & (unsigned long)0x01fc0000) != 0x00cc0000)
3017
              {
3018
                info->callbacks->einfo
3019
                  (_("%H: R_FRV_GOTTLSDESC12"
3020
                     " not applied to an lddi instruction\n"),
3021
                   input_bfd, input_section, rel->r_offset);
3022
                return FALSE;
3023
              }
3024
 
3025
            if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3026
                                            relocation + rel->r_addend)
3027
                && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3028
                                                  info))
3029
              {
3030
                /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3031
                   with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3032
                   Preserve the packing bit.  */
3033
                insn = (insn & (unsigned long)0x80000000)
3034
                  | ((insn + (unsigned long)0x02000000)
3035
                     & (unsigned long)0x7e000000);
3036
                insn |= (unsigned long)0x00fc0000;
3037
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3038
 
3039
                r_type = R_FRV_TLSMOFFLO;
3040
                howto  = elf32_frv_howto_table + r_type;
3041
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3042
              }
3043
 
3044
            else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3045
                                                 relocation + rel->r_addend))
3046
              {
3047
                /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3048
                   with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3049
                   Preserve the packing bit.  */
3050
                insn = (insn & (unsigned long)0x80000000)
3051
                  | ((insn + (unsigned long)0x02000000)
3052
                     & (unsigned long)0x7e000000);
3053
                insn |= (unsigned long)0x00f80000;
3054
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3055
 
3056
                r_type = R_FRV_TLSMOFFHI;
3057
                howto  = elf32_frv_howto_table + r_type;
3058
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3059
              }
3060
 
3061
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3062
              {
3063
                /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3064
                   with ldi @(grB, #gottlsoff12(symbol+offset),
3065
                   gr<C+1>.  Preserve the packing bit.  If gottlsoff12
3066
                   overflows, we'll error out, but that's sort-of ok,
3067
                   since we'd started with gottlsdesc12, that's actually
3068
                   more demanding.  Compiling with -fPIE instead of
3069
                   -fpie would fix it; linking with --relax should fix
3070
                   it as well.  */
3071
                insn = (insn & (unsigned long)0x80cbf000)
3072
                  | ((insn + (unsigned long)0x02000000)
3073
                     & (unsigned long)0x7e000000);
3074
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3075
 
3076
                r_type = R_FRV_GOTTLSOFF12;
3077
                howto  = elf32_frv_howto_table + r_type;
3078
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3079
              }
3080
 
3081
            break;
3082
 
3083
          case R_FRV_GOTTLSDESCHI:
3084
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3085
 
3086
            /* Is this a sethi instruction?  */
3087
            if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3088
              {
3089
                info->callbacks->einfo
3090
                  (_("%H: R_FRV_GOTTLSDESCHI"
3091
                     " not applied to a sethi instruction\n"),
3092
                   input_bfd, input_section, rel->r_offset);
3093
                return FALSE;
3094
              }
3095
 
3096
            if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3097
                                            relocation + rel->r_addend)
3098
                || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3099
                    && IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry)))
3100
              {
3101
                /* Replace sethi with a nop.  Preserve the packing bit.  */
3102
                insn &= (unsigned long)0x80000000;
3103
                insn |= (unsigned long)0x00880000;
3104
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3105
 
3106
                /* Nothing to relocate.  */
3107
                continue;
3108
              }
3109
 
3110
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3111
              {
3112
                /* Simply decay GOTTLSDESC to GOTTLSOFF.  */
3113
                r_type = R_FRV_GOTTLSOFFHI;
3114
                howto  = elf32_frv_howto_table + r_type;
3115
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3116
              }
3117
 
3118
            break;
3119
 
3120
          case R_FRV_GOTTLSDESCLO:
3121
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3122
 
3123
            /* Is this a setlo or setlos instruction?  */
3124
            if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3125
              {
3126
                info->callbacks->einfo
3127
                  (_("%H: R_FRV_GOTTLSDESCLO"
3128
                     " not applied to a setlo or setlos instruction\n"),
3129
                   input_bfd, input_section, rel->r_offset);
3130
                return FALSE;
3131
              }
3132
 
3133
            if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3134
                                            relocation + rel->r_addend)
3135
                || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3136
                    && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3137
              {
3138
                /* Replace setlo/setlos with a nop.  Preserve the
3139
                   packing bit.  */
3140
                insn &= (unsigned long)0x80000000;
3141
                insn |= (unsigned long)0x00880000;
3142
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3143
 
3144
                /* Nothing to relocate.  */
3145
                continue;
3146
              }
3147
 
3148
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3149
              {
3150
                /* If the corresponding sethi (if it exists) decayed
3151
                   to a nop, make sure this becomes (or already is) a
3152
                   setlos, not setlo.  */
3153
                if (IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry))
3154
                  {
3155
                    insn |= (unsigned long)0x00080000;
3156
                    bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3157
                  }
3158
 
3159
                /* Simply decay GOTTLSDESC to GOTTLSOFF.  */
3160
                r_type = R_FRV_GOTTLSOFFLO;
3161
                howto  = elf32_frv_howto_table + r_type;
3162
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3163
              }
3164
 
3165
            break;
3166
 
3167
          case R_FRV_TLSDESC_RELAX:
3168
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3169
 
3170
            /* Is this an ldd instruction?  */
3171
            if ((insn & (unsigned long)0x01fc0fc0) != 0x00080140)
3172
              {
3173
                info->callbacks->einfo
3174
                  (_("%H: R_FRV_TLSDESC_RELAX"
3175
                     " not applied to an ldd instruction\n"),
3176
                   input_bfd, input_section, rel->r_offset);
3177
                return FALSE;
3178
              }
3179
 
3180
            if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3181
                                            relocation + rel->r_addend)
3182
                && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3183
                                                  info))
3184
              {
3185
                /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3186
                   with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3187
                   Preserve the packing bit.  */
3188
                insn = (insn & (unsigned long)0x80000000)
3189
                  | ((insn + (unsigned long)0x02000000)
3190
                     & (unsigned long)0x7e000000);
3191
                insn |= (unsigned long)0x00fc0000;
3192
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3193
 
3194
                r_type = R_FRV_TLSMOFFLO;
3195
                howto  = elf32_frv_howto_table + r_type;
3196
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3197
              }
3198
 
3199
            else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3200
                                                 relocation + rel->r_addend))
3201
              {
3202
                /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3203
                   with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3204
                   Preserve the packing bit.  */
3205
                insn = (insn & (unsigned long)0x80000000)
3206
                  | ((insn + (unsigned long)0x02000000)
3207
                     & (unsigned long)0x7e000000);
3208
                insn |= (unsigned long)0x00f80000;
3209
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3210
 
3211
                r_type = R_FRV_TLSMOFFHI;
3212
                howto  = elf32_frv_howto_table + r_type;
3213
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3214
              }
3215
 
3216
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3217
                     && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))
3218
              {
3219
                /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3220
                   with ldi @(grB, #gottlsoff12(symbol+offset), gr<C+1>.
3221
                   Preserve the packing bit.  */
3222
                insn = (insn & (unsigned long)0x8003f000)
3223
                  | (unsigned long)0x00c80000
3224
                  | ((insn + (unsigned long)0x02000000)
3225
                     & (unsigned long)0x7e000000);
3226
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3227
 
3228
                r_type = R_FRV_GOTTLSOFF12;
3229
                howto  = elf32_frv_howto_table + r_type;
3230
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3231
              }
3232
 
3233
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3234
              {
3235
                /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3236
                   with ld #tlsoff(symbol+offset)@(grB, grA), gr<C+1>.
3237
                   Preserve the packing bit.  */
3238
                insn = (insn & (unsigned long)0x81ffffbf)
3239
                  | ((insn + (unsigned long)0x02000000)
3240
                     & (unsigned long)0x7e000000);
3241
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3242
 
3243
                /* #tlsoff(symbol+offset) is just a relaxation
3244
                    annotation, so there's nothing left to
3245
                    relocate.  */
3246
                continue;
3247
              }
3248
 
3249
            break;
3250
 
3251
          case R_FRV_GETTLSOFF_RELAX:
3252
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3253
 
3254
            /* Is this a calll or callil instruction?  */
3255
            if ((insn & (unsigned long)0x7ff80fc0) != 0x02300000)
3256
              {
3257
                info->callbacks->einfo
3258
                  (_("%H: R_FRV_GETTLSOFF_RELAX"
3259
                     " not applied to a calll instruction\n"),
3260
                   input_bfd, input_section, rel->r_offset);
3261
                return FALSE;
3262
              }
3263
 
3264
            if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3265
                                            relocation + rel->r_addend)
3266
                && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3267
                                                  info))
3268
              {
3269
                /* Replace calll with a nop.  Preserve the packing bit.  */
3270
                insn &= (unsigned long)0x80000000;
3271
                insn |= (unsigned long)0x00880000;
3272
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3273
 
3274
                /* Nothing to relocate.  */
3275
                continue;
3276
              }
3277
 
3278
            else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3279
                                                 relocation + rel->r_addend))
3280
              {
3281
                /* Replace calll with setlo #tlsmofflo(symbol+offset), gr9.
3282
                   Preserve the packing bit.  */
3283
                insn &= (unsigned long)0x80000000;
3284
                insn |= (unsigned long)0x12f40000;
3285
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3286
 
3287
                r_type = R_FRV_TLSMOFFLO;
3288
                howto  = elf32_frv_howto_table + r_type;
3289
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3290
              }
3291
 
3292
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3293
              {
3294
                /* Replace calll with a nop.  Preserve the packing bit.  */
3295
                insn &= (unsigned long)0x80000000;
3296
                insn |= (unsigned long)0x00880000;
3297
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3298
 
3299
                /* Nothing to relocate.  */
3300
                continue;
3301
              }
3302
 
3303
            break;
3304
 
3305
          case R_FRV_GOTTLSOFF12:
3306
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3307
 
3308
            /* Is this an ldi instruction?  */
3309
            if ((insn & (unsigned long)0x01fc0000) != 0x00c80000)
3310
              {
3311
                info->callbacks->einfo
3312
                  (_("%H: R_FRV_GOTTLSOFF12"
3313
                     " not applied to an ldi instruction\n"),
3314
                   input_bfd, input_section, rel->r_offset);
3315
                return FALSE;
3316
              }
3317
 
3318
            if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3319
                                              relocation + rel->r_addend))
3320
              {
3321
                /* Replace ldi @(grB, #gottlsoff12(symbol+offset), grC
3322
                   with setlos #tlsmofflo(symbol+offset), grC.
3323
                   Preserve the packing bit.  */
3324
                insn &= (unsigned long)0xfe000000;
3325
                insn |= (unsigned long)0x00fc0000;
3326
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3327
 
3328
                r_type = R_FRV_TLSMOFFLO;
3329
                howto  = elf32_frv_howto_table + r_type;
3330
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3331
              }
3332
 
3333
            break;
3334
 
3335
          case R_FRV_GOTTLSOFFHI:
3336
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3337
 
3338
            /* Is this a sethi instruction?  */
3339
            if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3340
              {
3341
                info->callbacks->einfo
3342
                  (_("%H: R_FRV_GOTTLSOFFHI"
3343
                     " not applied to a sethi instruction\n"),
3344
                   input_bfd, input_section, rel->r_offset);
3345
                return FALSE;
3346
              }
3347
 
3348
            if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3349
                                              relocation + rel->r_addend)
3350
                || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3351
                    && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3352
              {
3353
                /* Replace sethi with a nop.  Preserve the packing bit.  */
3354
                insn &= (unsigned long)0x80000000;
3355
                insn |= (unsigned long)0x00880000;
3356
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3357
 
3358
                /* Nothing to relocate.  */
3359
                continue;
3360
              }
3361
 
3362
            break;
3363
 
3364
          case R_FRV_GOTTLSOFFLO:
3365
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3366
 
3367
            /* Is this a setlo or setlos instruction?  */
3368
            if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3369
              {
3370
                info->callbacks->einfo
3371
                  (_("%H: R_FRV_GOTTLSOFFLO"
3372
                     " not applied to a setlo or setlos instruction\n"),
3373
                   input_bfd, input_section, rel->r_offset);
3374
                return FALSE;
3375
              }
3376
 
3377
            if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3378
                                              relocation + rel->r_addend)
3379
                || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3380
                    && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3381
              {
3382
                /* Replace setlo/setlos with a nop.  Preserve the
3383
                   packing bit.  */
3384
                insn &= (unsigned long)0x80000000;
3385
                insn |= (unsigned long)0x00880000;
3386
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3387
 
3388
                /* Nothing to relocate.  */
3389
                continue;
3390
              }
3391
 
3392
            break;
3393
 
3394
          case R_FRV_TLSOFF_RELAX:
3395
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3396
 
3397
            /* Is this an ld instruction?  */
3398
            if ((insn & (unsigned long)0x01fc0fc0) != 0x00080100)
3399
              {
3400
                info->callbacks->einfo
3401
                  (_("%H: R_FRV_TLSOFF_RELAX"
3402
                     " not applied to an ld instruction\n"),
3403
                   input_bfd, input_section, rel->r_offset);
3404
                return FALSE;
3405
              }
3406
 
3407
            if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3408
                                              relocation + rel->r_addend))
3409
              {
3410
                /* Replace ld #gottlsoff(symbol+offset)@(grB, grA), grC
3411
                   with setlos #tlsmofflo(symbol+offset), grC.
3412
                   Preserve the packing bit.  */
3413
                insn &= (unsigned long)0xfe000000;
3414
                insn |= (unsigned long)0x00fc0000;
3415
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3416
 
3417
                r_type = R_FRV_TLSMOFFLO;
3418
                howto  = elf32_frv_howto_table + r_type;
3419
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3420
              }
3421
 
3422
            else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3423
                     && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))
3424
              {
3425
                /* Replace ld #tlsoff(symbol+offset)@(grB, grA), grC
3426
                   with ldi @(grB, #gottlsoff12(symbol+offset), grC.
3427
                   Preserve the packing bit.  */
3428
                insn = (insn & (unsigned long)0xfe03f000)
3429
                  | (unsigned long)0x00c80000;;
3430
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3431
 
3432
                r_type = R_FRV_GOTTLSOFF12;
3433
                howto  = elf32_frv_howto_table + r_type;
3434
                rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3435
              }
3436
 
3437
            break;
3438
 
3439
          case R_FRV_TLSMOFFHI:
3440
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3441
 
3442
            /* Is this a sethi instruction?  */
3443
            if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3444
              {
3445
                info->callbacks->einfo
3446
                  (_("%H: R_FRV_TLSMOFFHI"
3447
                     " not applied to a sethi instruction\n"),
3448
                   input_bfd, input_section, rel->r_offset);
3449
                return FALSE;
3450
              }
3451
 
3452
            if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3453
                                               info))
3454
              {
3455
                /* Replace sethi with a nop.  Preserve the packing bit.  */
3456
                insn &= (unsigned long)0x80000000;
3457
                insn |= (unsigned long)0x00880000;
3458
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3459
 
3460
                /* Nothing to relocate.  */
3461
                continue;
3462
              }
3463
 
3464
            break;
3465
 
3466
          case R_FRV_TLSMOFFLO:
3467
            insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3468
 
3469
            /* Is this a setlo or setlos instruction?  */
3470
            if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3471
              {
3472
                info->callbacks->einfo
3473
                  (_("R_FRV_TLSMOFFLO"
3474
                     " not applied to a setlo or setlos instruction\n"),
3475
                   input_bfd, input_section, rel->r_offset);
3476
                return FALSE;
3477
              }
3478
 
3479
            if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3480
                                               info))
3481
              /* If the corresponding sethi (if it exists) decayed
3482
                 to a nop, make sure this becomes (or already is) a
3483
                 setlos, not setlo.  */
3484
              {
3485
                insn |= (unsigned long)0x00080000;
3486
                bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3487
              }
3488
 
3489
            break;
3490
 
3491
            /*
3492
              There's nothing to relax in these:
3493
                R_FRV_TLSDESC_VALUE
3494
                R_FRV_TLSOFF
3495
                R_FRV_TLSMOFF12
3496
                R_FRV_TLSMOFFHI
3497
                R_FRV_TLSMOFFLO
3498
                R_FRV_TLSMOFF
3499
            */
3500
 
3501
          default:
3502
            break;
3503
          }
3504
 
3505
      switch (r_type)
3506
        {
3507
        case R_FRV_LABEL24:
3508
          check_segment[0] = isec_segment;
3509
          if (! IS_FDPIC (output_bfd))
3510
            check_segment[1] = isec_segment;
3511
          else if (picrel->plt)
3512
            {
3513
              relocation = frvfdpic_plt_section (info)->output_section->vma
3514
                + frvfdpic_plt_section (info)->output_offset
3515
                + picrel->plt_entry;
3516
              check_segment[1] = plt_segment;
3517
            }
3518
          /* We don't want to warn on calls to undefined weak symbols,
3519
             as calls to them must be protected by non-NULL tests
3520
             anyway, and unprotected calls would invoke undefined
3521
             behavior.  */
3522
          else if (picrel->symndx == -1
3523
                   && picrel->d.h->root.type == bfd_link_hash_undefweak)
3524
            check_segment[1] = check_segment[0];
3525
          else
3526
            check_segment[1] = sec
3527
              ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3528
              : (unsigned)-1;
3529
          break;
3530
 
3531
        case R_FRV_GOT12:
3532
        case R_FRV_GOTHI:
3533
        case R_FRV_GOTLO:
3534
          relocation = picrel->got_entry;
3535
          check_segment[0] = check_segment[1] = got_segment;
3536
          break;
3537
 
3538
        case R_FRV_FUNCDESC_GOT12:
3539
        case R_FRV_FUNCDESC_GOTHI:
3540
        case R_FRV_FUNCDESC_GOTLO:
3541
          relocation = picrel->fdgot_entry;
3542
          check_segment[0] = check_segment[1] = got_segment;
3543
          break;
3544
 
3545
        case R_FRV_GOTOFFHI:
3546
        case R_FRV_GOTOFF12:
3547
        case R_FRV_GOTOFFLO:
3548
          relocation -= frvfdpic_got_section (info)->output_section->vma
3549
            + frvfdpic_got_section (info)->output_offset
3550
            + frvfdpic_got_initial_offset (info);
3551
          check_segment[0] = got_segment;
3552
          check_segment[1] = sec
3553
            ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3554
            : (unsigned)-1;
3555
          break;
3556
 
3557
        case R_FRV_FUNCDESC_GOTOFF12:
3558
        case R_FRV_FUNCDESC_GOTOFFHI:
3559
        case R_FRV_FUNCDESC_GOTOFFLO:
3560
          relocation = picrel->fd_entry;
3561
          check_segment[0] = check_segment[1] = got_segment;
3562
          break;
3563
 
3564
        case R_FRV_FUNCDESC:
3565
          {
3566
            int dynindx;
3567
            bfd_vma addend = rel->r_addend;
3568
 
3569
            if (! (h && h->root.type == bfd_link_hash_undefweak
3570
                   && FRVFDPIC_SYM_LOCAL (info, h)))
3571
              {
3572
                /* If the symbol is dynamic and there may be dynamic
3573
                   symbol resolution because we are or are linked with a
3574
                   shared library, emit a FUNCDESC relocation such that
3575
                   the dynamic linker will allocate the function
3576
                   descriptor.  If the symbol needs a non-local function
3577
                   descriptor but binds locally (e.g., its visibility is
3578
                   protected, emit a dynamic relocation decayed to
3579
                   section+offset.  */
3580
                if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h)
3581
                    && FRVFDPIC_SYM_LOCAL (info, h)
3582
                    && !(info->executable && !info->pie))
3583
                  {
3584
                    dynindx = elf_section_data (h->root.u.def.section
3585
                                                ->output_section)->dynindx;
3586
                    addend += h->root.u.def.section->output_offset
3587
                      + h->root.u.def.value;
3588
                  }
3589
                else if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h))
3590
                  {
3591
                    if (addend)
3592
                      {
3593
                        info->callbacks->einfo
3594
                          (_("%H: R_FRV_FUNCDESC references dynamic symbol"
3595
                             " with nonzero addend\n"),
3596
                           input_bfd, input_section, rel->r_offset);
3597
                        return FALSE;
3598
                      }
3599
                    dynindx = h->dynindx;
3600
                  }
3601
                else
3602
                  {
3603
                    /* Otherwise, we know we have a private function
3604
                       descriptor, so reference it directly.  */
3605
                    BFD_ASSERT (picrel->privfd);
3606
                    r_type = R_FRV_32;
3607
                    dynindx = elf_section_data (frvfdpic_got_section (info)
3608
                                                ->output_section)->dynindx;
3609
                    addend = frvfdpic_got_section (info)->output_offset
3610
                      + frvfdpic_got_initial_offset (info)
3611
                      + picrel->fd_entry;
3612
                  }
3613
 
3614
                /* If there is room for dynamic symbol resolution, emit
3615
                   the dynamic relocation.  However, if we're linking an
3616
                   executable at a fixed location, we won't have emitted a
3617
                   dynamic symbol entry for the got section, so idx will
3618
                   be zero, which means we can and should compute the
3619
                   address of the private descriptor ourselves.  */
3620
                if (info->executable && !info->pie
3621
                    && (!h || FRVFDPIC_FUNCDESC_LOCAL (info, h)))
3622
                  {
3623
                    addend += frvfdpic_got_section (info)->output_section->vma;
3624
                    if ((bfd_get_section_flags (output_bfd,
3625
                                                input_section->output_section)
3626
                         & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3627
                      {
3628
                        bfd_vma offset;
3629
 
3630
                        if (_frvfdpic_osec_readonly_p (output_bfd,
3631
                                                       input_section
3632
                                                       ->output_section))
3633
                          {
3634
                            info->callbacks->einfo
3635
                              (_("%H: cannot emit fixups"
3636
                                 " in read-only section\n"),
3637
                               input_bfd, input_section, rel->r_offset);
3638
                            return FALSE;
3639
                          }
3640
 
3641
                        offset = _bfd_elf_section_offset
3642
                          (output_bfd, info,
3643
                           input_section, rel->r_offset);
3644
 
3645
                        if (offset != (bfd_vma)-1)
3646
                          _frvfdpic_add_rofixup (output_bfd,
3647
                                                 frvfdpic_gotfixup_section
3648
                                                 (info),
3649
                                                 offset + input_section
3650
                                                 ->output_section->vma
3651
                                                 + input_section->output_offset,
3652
                                                 picrel);
3653
                      }
3654
                  }
3655
                else if ((bfd_get_section_flags (output_bfd,
3656
                                                 input_section->output_section)
3657
                          & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3658
                  {
3659
                    bfd_vma offset;
3660
 
3661
                    if (_frvfdpic_osec_readonly_p (output_bfd,
3662
                                                   input_section
3663
                                                   ->output_section))
3664
                      {
3665
                        info->callbacks->einfo
3666
                          (_("%H: cannot emit dynamic relocations"
3667
                             " in read-only section\n"),
3668
                           input_bfd, input_section, rel->r_offset);
3669
                        return FALSE;
3670
                      }
3671
 
3672
                    offset = _bfd_elf_section_offset
3673
                      (output_bfd, info,
3674
                       input_section, rel->r_offset);
3675
 
3676
                    if (offset != (bfd_vma)-1)
3677
                      _frvfdpic_add_dyn_reloc (output_bfd,
3678
                                               frvfdpic_gotrel_section (info),
3679
                                               offset + input_section
3680
                                               ->output_section->vma
3681
                                               + input_section->output_offset,
3682
                                               r_type, dynindx, addend, picrel);
3683
                  }
3684
                else
3685
                  addend += frvfdpic_got_section (info)->output_section->vma;
3686
              }
3687
 
3688
            /* We want the addend in-place because dynamic
3689
               relocations are REL.  Setting relocation to it should
3690
               arrange for it to be installed.  */
3691
            relocation = addend - rel->r_addend;
3692
          }
3693
          check_segment[0] = check_segment[1] = got_segment;
3694
          break;
3695
 
3696
        case R_FRV_32:
3697
          if (! IS_FDPIC (output_bfd))
3698
            {
3699
              check_segment[0] = check_segment[1] = -1;
3700
              break;
3701
            }
3702
          /* Fall through.  */
3703
        case R_FRV_FUNCDESC_VALUE:
3704
          {
3705
            int dynindx;
3706
            bfd_vma addend = rel->r_addend;
3707
 
3708
            /* If the symbol is dynamic but binds locally, use
3709
               section+offset.  */
3710
            if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
3711
              {
3712
                if (addend && r_type == R_FRV_FUNCDESC_VALUE)
3713
                  {
3714
                    info->callbacks->einfo
3715
                      (_("%H: R_FRV_FUNCDESC_VALUE"
3716
                         " references dynamic symbol with nonzero addend\n"),
3717
                       input_bfd, input_section, rel->r_offset);
3718
                    return FALSE;
3719
                  }
3720
                dynindx = h->dynindx;
3721
              }
3722
            else
3723
              {
3724
                if (h)
3725
                  addend += h->root.u.def.value;
3726
                else
3727
                  addend += sym->st_value;
3728
                if (osec)
3729
                  addend += osec->output_offset;
3730
                if (osec && osec->output_section
3731
                    && ! bfd_is_abs_section (osec->output_section)
3732
                    && ! bfd_is_und_section (osec->output_section))
3733
                  dynindx = elf_section_data (osec->output_section)->dynindx;
3734
                else
3735
                  dynindx = 0;
3736
              }
3737
 
3738
            /* If we're linking an executable at a fixed address, we
3739
               can omit the dynamic relocation as long as the symbol
3740
               is defined in the current link unit (which is implied
3741
               by its output section not being NULL).  */
3742
            if (info->executable && !info->pie
3743
                && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
3744
              {
3745
                if (osec)
3746
                  addend += osec->output_section->vma;
3747
                if (IS_FDPIC (input_bfd)
3748
                    && (bfd_get_section_flags (output_bfd,
3749
                                               input_section->output_section)
3750
                        & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3751
                  {
3752
                    if (_frvfdpic_osec_readonly_p (output_bfd,
3753
                                                   input_section
3754
                                                   ->output_section))
3755
                      {
3756
                        info->callbacks->einfo
3757
                          (_("%H: cannot emit fixups in read-only section\n"),
3758
                           input_bfd, input_section, rel->r_offset);
3759
                        return FALSE;
3760
                      }
3761
                    if (!h || h->root.type != bfd_link_hash_undefweak)
3762
                      {
3763
                        bfd_vma offset = _bfd_elf_section_offset
3764
                          (output_bfd, info,
3765
                           input_section, rel->r_offset);
3766
 
3767
                        if (offset != (bfd_vma)-1)
3768
                          {
3769
                            _frvfdpic_add_rofixup (output_bfd,
3770
                                                   frvfdpic_gotfixup_section
3771
                                                   (info),
3772
                                                   offset + input_section
3773
                                                   ->output_section->vma
3774
                                                   + input_section->output_offset,
3775
                                                   picrel);
3776
                            if (r_type == R_FRV_FUNCDESC_VALUE)
3777
                              _frvfdpic_add_rofixup
3778
                                (output_bfd,
3779
                                 frvfdpic_gotfixup_section (info),
3780
                                 offset
3781
                                 + input_section->output_section->vma
3782
                                 + input_section->output_offset + 4, picrel);
3783
                          }
3784
                      }
3785
                  }
3786
              }
3787
            else
3788
              {
3789
                if ((bfd_get_section_flags (output_bfd,
3790
                                            input_section->output_section)
3791
                     & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3792
                  {
3793
                    bfd_vma offset;
3794
 
3795
                    if (_frvfdpic_osec_readonly_p (output_bfd,
3796
                                                   input_section
3797
                                                   ->output_section))
3798
                      {
3799
                        info->callbacks->einfo
3800
                          (_("%H: cannot emit dynamic relocations"
3801
                             " in read-only section\n"),
3802
                           input_bfd, input_section, rel->r_offset);
3803
                        return FALSE;
3804
                      }
3805
 
3806
                    offset = _bfd_elf_section_offset
3807
                      (output_bfd, info,
3808
                       input_section, rel->r_offset);
3809
 
3810
                    if (offset != (bfd_vma)-1)
3811
                      _frvfdpic_add_dyn_reloc (output_bfd,
3812
                                               frvfdpic_gotrel_section (info),
3813
                                               offset + input_section
3814
                                               ->output_section->vma
3815
                                               + input_section->output_offset,
3816
                                               r_type, dynindx, addend, picrel);
3817
                  }
3818
                else if (osec)
3819
                  addend += osec->output_section->vma;
3820
                /* We want the addend in-place because dynamic
3821
                   relocations are REL.  Setting relocation to it
3822
                   should arrange for it to be installed.  */
3823
                relocation = addend - rel->r_addend;
3824
              }
3825
 
3826
            if (r_type == R_FRV_FUNCDESC_VALUE)
3827
              {
3828
                /* If we've omitted the dynamic relocation, just emit
3829
                   the fixed addresses of the symbol and of the local
3830
                   GOT base offset.  */
3831
                if (info->executable && !info->pie
3832
                    && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
3833
                  bfd_put_32 (output_bfd,
3834
                              frvfdpic_got_section (info)->output_section->vma
3835
                              + frvfdpic_got_section (info)->output_offset
3836
                              + frvfdpic_got_initial_offset (info),
3837
                              contents + rel->r_offset + 4);
3838
                else
3839
                  /* A function descriptor used for lazy or local
3840
                     resolving is initialized such that its high word
3841
                     contains the output section index in which the
3842
                     PLT entries are located, and the low word
3843
                     contains the offset of the lazy PLT entry entry
3844
                     point into that section.  */
3845
                  bfd_put_32 (output_bfd,
3846
                              h && ! FRVFDPIC_SYM_LOCAL (info, h)
3847
                              ? 0
3848
                              : _frvfdpic_osec_to_segment (output_bfd,
3849
                                                           sec
3850
                                                           ->output_section),
3851
                              contents + rel->r_offset + 4);
3852
              }
3853
          }
3854
          check_segment[0] = check_segment[1] = got_segment;
3855
          break;
3856
 
3857
        case R_FRV_GPREL12:
3858
        case R_FRV_GPRELU12:
3859
        case R_FRV_GPREL32:
3860
        case R_FRV_GPRELHI:
3861
        case R_FRV_GPRELLO:
3862
          check_segment[0] = gprel_segment;
3863
          check_segment[1] = sec
3864
            ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3865
            : (unsigned)-1;
3866
          break;
3867
 
3868
        case R_FRV_GETTLSOFF:
3869
          relocation = frvfdpic_plt_section (info)->output_section->vma
3870
            + frvfdpic_plt_section (info)->output_offset
3871
            + picrel->tlsplt_entry;
3872
          BFD_ASSERT (picrel->tlsplt_entry != (bfd_vma)-1
3873
                      && picrel->tlsdesc_entry);
3874
          check_segment[0] = isec_segment;
3875
          check_segment[1] = plt_segment;
3876
          break;
3877
 
3878
        case R_FRV_GOTTLSDESC12:
3879
        case R_FRV_GOTTLSDESCHI:
3880
        case R_FRV_GOTTLSDESCLO:
3881
          BFD_ASSERT (picrel->tlsdesc_entry);
3882
          relocation = picrel->tlsdesc_entry;
3883
          check_segment[0] = tls_segment;
3884
          check_segment[1] = sec
3885
            && ! bfd_is_abs_section (sec)
3886
            && ! bfd_is_und_section (sec)
3887
            ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3888
            : tls_segment;
3889
          break;
3890
 
3891
        case R_FRV_TLSMOFF12:
3892
        case R_FRV_TLSMOFFHI:
3893
        case R_FRV_TLSMOFFLO:
3894
        case R_FRV_TLSMOFF:
3895
          check_segment[0] = tls_segment;
3896
          if (! sec)
3897
            check_segment[1] = -1;
3898
          else if (bfd_is_abs_section (sec)
3899
                   || bfd_is_und_section (sec))
3900
            {
3901
              relocation = 0;
3902
              check_segment[1] = tls_segment;
3903
            }
3904
          else if (sec->output_section)
3905
            {
3906
              relocation -= tls_biased_base (info);
3907
              check_segment[1] =
3908
                _frvfdpic_osec_to_segment (output_bfd, sec->output_section);
3909
            }
3910
          else
3911
            check_segment[1] = -1;
3912
          break;
3913
 
3914
        case R_FRV_GOTTLSOFF12:
3915
        case R_FRV_GOTTLSOFFHI:
3916
        case R_FRV_GOTTLSOFFLO:
3917
          BFD_ASSERT (picrel->tlsoff_entry);
3918
          relocation = picrel->tlsoff_entry;
3919
          check_segment[0] = tls_segment;
3920
          check_segment[1] = sec
3921
            && ! bfd_is_abs_section (sec)
3922
            && ! bfd_is_und_section (sec)
3923
            ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3924
            : tls_segment;
3925
          break;
3926
 
3927
        case R_FRV_TLSDESC_VALUE:
3928
        case R_FRV_TLSOFF:
3929
          /* These shouldn't be present in input object files.  */
3930
          check_segment[0] = check_segment[1] = isec_segment;
3931
          break;
3932
 
3933
        case R_FRV_TLSDESC_RELAX:
3934
        case R_FRV_GETTLSOFF_RELAX:
3935
        case R_FRV_TLSOFF_RELAX:
3936
          /* These are just annotations for relaxation, nothing to do
3937
             here.  */
3938
          continue;
3939
 
3940
        default:
3941
          check_segment[0] = isec_segment;
3942
          check_segment[1] = sec
3943
            ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3944
            : (unsigned)-1;
3945
          break;
3946
        }
3947
 
3948
      if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd))
3949
        {
3950
          /* If you take this out, remove the #error from fdpic-static-6.d
3951
             in the ld testsuite.  */
3952
          /* This helps catch problems in GCC while we can't do more
3953
             than static linking.  The idea is to test whether the
3954
             input file basename is crt0.o only once.  */
3955
          if (silence_segment_error == 1)
3956
            silence_segment_error =
3957
              (strlen (input_bfd->filename) == 6
3958
               && filename_cmp (input_bfd->filename, "crt0.o") == 0)
3959
              || (strlen (input_bfd->filename) > 6
3960
                  && filename_cmp (input_bfd->filename
3961
                                   + strlen (input_bfd->filename) - 7,
3962
                             "/crt0.o") == 0)
3963
              ? -1 : 0;
3964
          if (!silence_segment_error
3965
              /* We don't want duplicate errors for undefined
3966
                 symbols.  */
3967
              && !(picrel && picrel->symndx == -1
3968
                   && picrel->d.h->root.type == bfd_link_hash_undefined))
3969
            {
3970
              info->callbacks->einfo
3971
                (_("%H: reloc against `%s' references a different segment\n"),
3972
                 input_bfd, input_section, rel->r_offset, name);
3973
            }
3974
          if (!silence_segment_error && (info->shared || info->pie))
3975
            return FALSE;
3976
          elf_elfheader (output_bfd)->e_flags |= EF_FRV_PIC;
3977
        }
3978
 
3979
      switch (r_type)
3980
        {
3981
        case R_FRV_GOTOFFHI:
3982
        case R_FRV_TLSMOFFHI:
3983
          /* We need the addend to be applied before we shift the
3984
             value right.  */
3985
          relocation += rel->r_addend;
3986
          /* Fall through.  */
3987
        case R_FRV_GOTHI:
3988
        case R_FRV_FUNCDESC_GOTHI:
3989
        case R_FRV_FUNCDESC_GOTOFFHI:
3990
        case R_FRV_GOTTLSOFFHI:
3991
        case R_FRV_GOTTLSDESCHI:
3992
          relocation >>= 16;
3993
          /* Fall through.  */
3994
 
3995
        case R_FRV_GOTLO:
3996
        case R_FRV_FUNCDESC_GOTLO:
3997
        case R_FRV_GOTOFFLO:
3998
        case R_FRV_FUNCDESC_GOTOFFLO:
3999
        case R_FRV_GOTTLSOFFLO:
4000
        case R_FRV_GOTTLSDESCLO:
4001
        case R_FRV_TLSMOFFLO:
4002
          relocation &= 0xffff;
4003
          break;
4004
 
4005
        default:
4006
          break;
4007
        }
4008
 
4009
      switch (r_type)
4010
        {
4011
        case R_FRV_LABEL24:
4012
          if (! IS_FDPIC (output_bfd) || ! picrel->plt)
4013
            break;
4014
          /* Fall through.  */
4015
 
4016
          /* When referencing a GOT entry, a function descriptor or a
4017
             PLT, we don't want the addend to apply to the reference,
4018
             but rather to the referenced symbol.  The actual entry
4019
             will have already been created taking the addend into
4020
             account, so cancel it out here.  */
4021
        case R_FRV_GOT12:
4022
        case R_FRV_GOTHI:
4023
        case R_FRV_GOTLO:
4024
        case R_FRV_FUNCDESC_GOT12:
4025
        case R_FRV_FUNCDESC_GOTHI:
4026
        case R_FRV_FUNCDESC_GOTLO:
4027
        case R_FRV_FUNCDESC_GOTOFF12:
4028
        case R_FRV_FUNCDESC_GOTOFFHI:
4029
        case R_FRV_FUNCDESC_GOTOFFLO:
4030
        case R_FRV_GETTLSOFF:
4031
        case R_FRV_GOTTLSDESC12:
4032
        case R_FRV_GOTTLSDESCHI:
4033
        case R_FRV_GOTTLSDESCLO:
4034
        case R_FRV_GOTTLSOFF12:
4035
        case R_FRV_GOTTLSOFFHI:
4036
        case R_FRV_GOTTLSOFFLO:
4037
          /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF12
4038
             here, since we do want to apply the addend to the others.
4039
             Note that we've applied the addend to GOTOFFHI before we
4040
             shifted it right.  */
4041
        case R_FRV_GOTOFFHI:
4042
        case R_FRV_TLSMOFFHI:
4043
          relocation -= rel->r_addend;
4044
          break;
4045
 
4046
        default:
4047
          break;
4048
        }
4049
 
4050
     if (r_type == R_FRV_HI16)
4051
       r = elf32_frv_relocate_hi16 (input_bfd, rel, contents, relocation);
4052
 
4053
     else if (r_type == R_FRV_LO16)
4054
       r = elf32_frv_relocate_lo16 (input_bfd, rel, contents, relocation);
4055
 
4056
     else if (r_type == R_FRV_LABEL24 || r_type == R_FRV_GETTLSOFF)
4057
       r = elf32_frv_relocate_label24 (input_bfd, input_section, rel,
4058
                                       contents, relocation);
4059
 
4060
     else if (r_type == R_FRV_GPREL12)
4061
       r = elf32_frv_relocate_gprel12 (info, input_bfd, input_section, rel,
4062
                                       contents, relocation);
4063
 
4064
     else if (r_type == R_FRV_GPRELU12)
4065
       r = elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, rel,
4066
                                        contents, relocation);
4067
 
4068
     else if (r_type == R_FRV_GPRELLO)
4069
       r = elf32_frv_relocate_gprello (info, input_bfd, input_section, rel,
4070
                                       contents, relocation);
4071
 
4072
     else if (r_type == R_FRV_GPRELHI)
4073
       r = elf32_frv_relocate_gprelhi (info, input_bfd, input_section, rel,
4074
                                       contents, relocation);
4075
 
4076
     else if (r_type == R_FRV_TLSOFF
4077
              || r_type == R_FRV_TLSDESC_VALUE)
4078
       r = bfd_reloc_notsupported;
4079
 
4080
     else
4081
       r = frv_final_link_relocate (howto, input_bfd, input_section, contents,
4082
                                    rel, relocation);
4083
 
4084
      if (r != bfd_reloc_ok)
4085
        {
4086
          const char * msg = (const char *) NULL;
4087
 
4088
          switch (r)
4089
            {
4090
            case bfd_reloc_overflow:
4091
              r = info->callbacks->reloc_overflow
4092
                (info, (h ? &h->root : NULL), name, howto->name,
4093
                 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4094
              break;
4095
 
4096
            case bfd_reloc_undefined:
4097
              r = info->callbacks->undefined_symbol
4098
                (info, name, input_bfd, input_section, rel->r_offset, TRUE);
4099
              break;
4100
 
4101
            case bfd_reloc_outofrange:
4102
              msg = _("internal error: out of range error");
4103
              break;
4104
 
4105
            case bfd_reloc_notsupported:
4106
              msg = _("internal error: unsupported relocation error");
4107
              break;
4108
 
4109
            case bfd_reloc_dangerous:
4110
              msg = _("internal error: dangerous relocation");
4111
              break;
4112
 
4113
            default:
4114
              msg = _("internal error: unknown error");
4115
              break;
4116
            }
4117
 
4118
          if (msg)
4119
            {
4120
              info->callbacks->einfo
4121
                (_("%H: reloc against `%s': %s\n"),
4122
                 input_bfd, input_section, rel->r_offset, name, msg);
4123
              return FALSE;
4124
            }
4125
 
4126
          if (! r)
4127
            return FALSE;
4128
        }
4129
    }
4130
 
4131
  return TRUE;
4132
}
4133
 
4134
/* Return the section that should be marked against GC for a given
4135
   relocation.  */
4136
 
4137
static asection *
4138
elf32_frv_gc_mark_hook (asection *sec,
4139
                        struct bfd_link_info *info,
4140
                        Elf_Internal_Rela *rel,
4141
                        struct elf_link_hash_entry *h,
4142
                        Elf_Internal_Sym *sym)
4143
{
4144
  if (h != NULL)
4145
    switch (ELF32_R_TYPE (rel->r_info))
4146
      {
4147
      case R_FRV_GNU_VTINHERIT:
4148
      case R_FRV_GNU_VTENTRY:
4149
        return NULL;
4150
      }
4151
 
4152
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4153
}
4154
 
4155
/* Hook called by the linker routine which adds symbols from an object
4156
   file.  We use it to put .comm items in .scomm, and not .comm.  */
4157
 
4158
static bfd_boolean
4159
elf32_frv_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
4160
     bfd *abfd;
4161
     struct bfd_link_info *info;
4162
     Elf_Internal_Sym *sym;
4163
     const char **namep ATTRIBUTE_UNUSED;
4164
     flagword *flagsp ATTRIBUTE_UNUSED;
4165
     asection **secp;
4166
     bfd_vma *valp;
4167
{
4168
  if (sym->st_shndx == SHN_COMMON
4169
      && !info->relocatable
4170
      && (int)sym->st_size <= (int)bfd_get_gp_size (abfd))
4171
    {
4172
      /* Common symbols less than or equal to -G nn bytes are
4173
         automatically put into .sbss.  */
4174
 
4175
      asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
4176
 
4177
      if (scomm == NULL)
4178
        {
4179
          scomm = bfd_make_section_with_flags (abfd, ".scommon",
4180
                                               (SEC_ALLOC
4181
                                                | SEC_IS_COMMON
4182
                                                | SEC_LINKER_CREATED));
4183
          if (scomm == NULL)
4184
            return FALSE;
4185
        }
4186
 
4187
      *secp = scomm;
4188
      *valp = sym->st_size;
4189
    }
4190
 
4191
  return TRUE;
4192
}
4193
 
4194
/* We need dynamic symbols for every section, since segments can
4195
   relocate independently.  */
4196
static bfd_boolean
4197
_frvfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
4198
                                    struct bfd_link_info *info
4199
                                    ATTRIBUTE_UNUSED,
4200
                                    asection *p ATTRIBUTE_UNUSED)
4201
{
4202
  switch (elf_section_data (p)->this_hdr.sh_type)
4203
    {
4204
    case SHT_PROGBITS:
4205
    case SHT_NOBITS:
4206
      /* If sh_type is yet undecided, assume it could be
4207
         SHT_PROGBITS/SHT_NOBITS.  */
4208
    case SHT_NULL:
4209
      return FALSE;
4210
 
4211
      /* There shouldn't be section relative relocations
4212
         against any other section.  */
4213
    default:
4214
      return TRUE;
4215
    }
4216
}
4217
 
4218
/* Create  a .got section, as well as its additional info field.  This
4219
   is almost entirely copied from
4220
   elflink.c:_bfd_elf_create_got_section().  */
4221
 
4222
static bfd_boolean
4223
_frv_create_got_section (bfd *abfd, struct bfd_link_info *info)
4224
{
4225
  flagword flags, pltflags;
4226
  asection *s;
4227
  struct elf_link_hash_entry *h;
4228
  struct bfd_link_hash_entry *bh;
4229
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4230
  int ptralign;
4231
  int offset;
4232
 
4233
  /* This function may be called more than once.  */
4234
  s = bfd_get_section_by_name (abfd, ".got");
4235
  if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
4236
    return TRUE;
4237
 
4238
  /* Machine specific: although pointers are 32-bits wide, we want the
4239
     GOT to be aligned to a 64-bit boundary, such that function
4240
     descriptors in it can be accessed with 64-bit loads and
4241
     stores.  */
4242
  ptralign = 3;
4243
 
4244
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4245
           | SEC_LINKER_CREATED);
4246
  pltflags = flags;
4247
 
4248
  s = bfd_make_section_with_flags (abfd, ".got", flags);
4249
  if (s == NULL
4250
      || !bfd_set_section_alignment (abfd, s, ptralign))
4251
    return FALSE;
4252
 
4253
  if (bed->want_got_plt)
4254
    {
4255
      s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
4256
      if (s == NULL
4257
          || !bfd_set_section_alignment (abfd, s, ptralign))
4258
        return FALSE;
4259
    }
4260
 
4261
  if (bed->want_got_sym)
4262
    {
4263
      /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
4264
         (or .got.plt) section.  We don't do this in the linker script
4265
         because we don't want to define the symbol if we are not creating
4266
         a global offset table.  */
4267
      h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
4268
      elf_hash_table (info)->hgot = h;
4269
      if (h == NULL)
4270
        return FALSE;
4271
 
4272
      /* Machine-specific: we want the symbol for executables as
4273
         well.  */
4274
      if (! bfd_elf_link_record_dynamic_symbol (info, h))
4275
        return FALSE;
4276
    }
4277
 
4278
  /* The first bit of the global offset table is the header.  */
4279
  s->size += bed->got_header_size;
4280
 
4281
  /* This is the machine-specific part.  Create and initialize section
4282
     data for the got.  */
4283
  if (IS_FDPIC (abfd))
4284
    {
4285
      frvfdpic_got_section (info) = s;
4286
      frvfdpic_relocs_info (info) = htab_try_create (1,
4287
                                                     frvfdpic_relocs_info_hash,
4288
                                                     frvfdpic_relocs_info_eq,
4289
                                                     (htab_del) NULL);
4290
      if (! frvfdpic_relocs_info (info))
4291
        return FALSE;
4292
 
4293
      s = bfd_make_section_with_flags (abfd, ".rel.got",
4294
                                       (flags | SEC_READONLY));
4295
      if (s == NULL
4296
          || ! bfd_set_section_alignment (abfd, s, 2))
4297
        return FALSE;
4298
 
4299
      frvfdpic_gotrel_section (info) = s;
4300
 
4301
      /* Machine-specific.  */
4302
      s = bfd_make_section_with_flags (abfd, ".rofixup",
4303
                                       (flags | SEC_READONLY));
4304
      if (s == NULL
4305
          || ! bfd_set_section_alignment (abfd, s, 2))
4306
        return FALSE;
4307
 
4308
      frvfdpic_gotfixup_section (info) = s;
4309
      offset = -2048;
4310
      flags = BSF_GLOBAL;
4311
    }
4312
  else
4313
    {
4314
      offset = 2048;
4315
      flags = BSF_GLOBAL | BSF_WEAK;
4316
    }
4317
 
4318
  /* Define _gp in .rofixup, for FDPIC, or .got otherwise.  If it
4319
     turns out that we're linking with a different linker script, the
4320
     linker script will override it.  */
4321
  bh = NULL;
4322
  if (!(_bfd_generic_link_add_one_symbol
4323
        (info, abfd, "_gp", flags, s, offset, (const char *) NULL, FALSE,
4324
         bed->collect, &bh)))
4325
    return FALSE;
4326
  h = (struct elf_link_hash_entry *) bh;
4327
  h->def_regular = 1;
4328
  h->type = STT_OBJECT;
4329
  /* h->other = STV_HIDDEN; */ /* Should we?  */
4330
 
4331
  /* Machine-specific: we want the symbol for executables as well.  */
4332
  if (IS_FDPIC (abfd) && ! bfd_elf_link_record_dynamic_symbol (info, h))
4333
    return FALSE;
4334
 
4335
  if (!IS_FDPIC (abfd))
4336
    return TRUE;
4337
 
4338
  /* FDPIC supports Thread Local Storage, and this may require a
4339
     procedure linkage table for TLS PLT entries.  */
4340
 
4341
  /* This is mostly copied from
4342
     elflink.c:_bfd_elf_create_dynamic_sections().  */
4343
 
4344
  flags = pltflags;
4345
  pltflags |= SEC_CODE;
4346
  if (bed->plt_not_loaded)
4347
    pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
4348
  if (bed->plt_readonly)
4349
    pltflags |= SEC_READONLY;
4350
 
4351
  s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
4352
  if (s == NULL
4353
      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
4354
    return FALSE;
4355
  /* FRV-specific: remember it.  */
4356
  frvfdpic_plt_section (info) = s;
4357
 
4358
  /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
4359
     .plt section.  */
4360
  if (bed->want_plt_sym)
4361
    {
4362
      h = _bfd_elf_define_linkage_sym (abfd, info, s,
4363
                                       "_PROCEDURE_LINKAGE_TABLE_");
4364
      elf_hash_table (info)->hplt = h;
4365
      if (h == NULL)
4366
        return FALSE;
4367
    }
4368
 
4369
  /* FRV-specific: we want rel relocations for the plt.  */
4370
  s = bfd_make_section_with_flags (abfd, ".rel.plt",
4371
                                   flags | SEC_READONLY);
4372
  if (s == NULL
4373
      || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
4374
    return FALSE;
4375
  /* FRV-specific: remember it.  */
4376
  frvfdpic_pltrel_section (info) = s;
4377
 
4378
  return TRUE;
4379
}
4380
 
4381
/* Make sure the got and plt sections exist, and that our pointers in
4382
   the link hash table point to them.  */
4383
 
4384
static bfd_boolean
4385
elf32_frvfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4386
{
4387
  /* This is mostly copied from
4388
     elflink.c:_bfd_elf_create_dynamic_sections().  */
4389
  flagword flags;
4390
  asection *s;
4391
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4392
 
4393
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4394
           | SEC_LINKER_CREATED);
4395
 
4396
  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4397
     .rel[a].bss sections.  */
4398
 
4399
  /* FRV-specific: we want to create the GOT and the PLT in the FRV
4400
     way.  */
4401
  if (! _frv_create_got_section (abfd, info))
4402
    return FALSE;
4403
 
4404
  /* FRV-specific: make sure we created everything we wanted.  */
4405
  BFD_ASSERT (frvfdpic_got_section (info) && frvfdpic_gotrel_section (info)
4406
              && frvfdpic_gotfixup_section (info)
4407
              && frvfdpic_plt_section (info)
4408
              && frvfdpic_pltrel_section (info));
4409
 
4410
  if (bed->want_dynbss)
4411
    {
4412
      /* The .dynbss section is a place to put symbols which are defined
4413
         by dynamic objects, are referenced by regular objects, and are
4414
         not functions.  We must allocate space for them in the process
4415
         image and use a R_*_COPY reloc to tell the dynamic linker to
4416
         initialize them at run time.  The linker script puts the .dynbss
4417
         section into the .bss section of the final image.  */
4418
      s = bfd_make_section_with_flags (abfd, ".dynbss",
4419
                                       SEC_ALLOC | SEC_LINKER_CREATED);
4420
      if (s == NULL)
4421
        return FALSE;
4422
 
4423
      /* The .rel[a].bss section holds copy relocs.  This section is not
4424
     normally needed.  We need to create it here, though, so that the
4425
     linker will map it to an output section.  We can't just create it
4426
     only if we need it, because we will not know whether we need it
4427
     until we have seen all the input files, and the first time the
4428
     main linker code calls BFD after examining all the input files
4429
     (size_dynamic_sections) the input sections have already been
4430
     mapped to the output sections.  If the section turns out not to
4431
     be needed, we can discard it later.  We will never need this
4432
     section when generating a shared object, since they do not use
4433
     copy relocs.  */
4434
      if (! info->shared)
4435
        {
4436
          s = bfd_make_section_with_flags (abfd,
4437
                                           (bed->default_use_rela_p
4438
                                            ? ".rela.bss" : ".rel.bss"),
4439
                                           flags | SEC_READONLY);
4440
          if (s == NULL
4441
              || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
4442
            return FALSE;
4443
        }
4444
    }
4445
 
4446
  return TRUE;
4447
}
4448
 
4449
/* Compute the total GOT and PLT size required by each symbol in each
4450
   range.  Symbols may require up to 4 words in the GOT: an entry
4451
   pointing to the symbol, an entry pointing to its function
4452
   descriptor, and a private function descriptors taking two
4453
   words.  */
4454
 
4455
static void
4456
_frvfdpic_count_nontls_entries (struct frvfdpic_relocs_info *entry,
4457
                                struct _frvfdpic_dynamic_got_info *dinfo)
4458
{
4459
  /* Allocate space for a GOT entry pointing to the symbol.  */
4460
  if (entry->got12)
4461
    dinfo->got12 += 4;
4462
  else if (entry->gotlos)
4463
    dinfo->gotlos += 4;
4464
  else if (entry->gothilo)
4465
    dinfo->gothilo += 4;
4466
  else
4467
    entry->relocs32--;
4468
  entry->relocs32++;
4469
 
4470
  /* Allocate space for a GOT entry pointing to the function
4471
     descriptor.  */
4472
  if (entry->fdgot12)
4473
    dinfo->got12 += 4;
4474
  else if (entry->fdgotlos)
4475
    dinfo->gotlos += 4;
4476
  else if (entry->fdgothilo)
4477
    dinfo->gothilo += 4;
4478
  else
4479
    entry->relocsfd--;
4480
  entry->relocsfd++;
4481
 
4482
  /* Decide whether we need a PLT entry, a function descriptor in the
4483
     GOT, and a lazy PLT entry for this symbol.  */
4484
  entry->plt = entry->call
4485
    && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4486
    && elf_hash_table (dinfo->info)->dynamic_sections_created;
4487
  entry->privfd = entry->plt
4488
    || entry->fdgoff12 || entry->fdgofflos || entry->fdgoffhilo
4489
    || ((entry->fd || entry->fdgot12 || entry->fdgotlos || entry->fdgothilo)
4490
        && (entry->symndx != -1
4491
            || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
4492
  entry->lazyplt = entry->privfd
4493
    && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4494
    && ! (dinfo->info->flags & DF_BIND_NOW)
4495
    && elf_hash_table (dinfo->info)->dynamic_sections_created;
4496
 
4497
  /* Allocate space for a function descriptor.  */
4498
  if (entry->fdgoff12)
4499
    dinfo->fd12 += 8;
4500
  else if (entry->fdgofflos)
4501
    dinfo->fdlos += 8;
4502
  else if (entry->privfd && entry->plt)
4503
    dinfo->fdplt += 8;
4504
  else if (entry->privfd)
4505
    dinfo->fdhilo += 8;
4506
  else
4507
    entry->relocsfdv--;
4508
  entry->relocsfdv++;
4509
 
4510
  if (entry->lazyplt)
4511
    dinfo->lzplt += 8;
4512
}
4513
 
4514
/* Compute the total GOT size required by each TLS symbol in each
4515
   range.  Symbols may require up to 5 words in the GOT: an entry
4516
   holding the TLS offset for the symbol, and an entry with a full TLS
4517
   descriptor taking 4 words.  */
4518
 
4519
static void
4520
_frvfdpic_count_tls_entries (struct frvfdpic_relocs_info *entry,
4521
                             struct _frvfdpic_dynamic_got_info *dinfo,
4522
                             bfd_boolean subtract)
4523
{
4524
  const int l = subtract ? -1 : 1;
4525
 
4526
  /* Allocate space for a GOT entry with the TLS offset of the
4527
     symbol.  */
4528
  if (entry->tlsoff12)
4529
    dinfo->got12 += 4 * l;
4530
  else if (entry->tlsofflos)
4531
    dinfo->gotlos += 4 * l;
4532
  else if (entry->tlsoffhilo)
4533
    dinfo->gothilo += 4 * l;
4534
  else
4535
    entry->relocstlsoff -= l;
4536
  entry->relocstlsoff += l;
4537
 
4538
  /* If there's any TLSOFF relocation, mark the output file as not
4539
     suitable for dlopening.  This mark will remain even if we relax
4540
     all such relocations, but this is not a problem, since we'll only
4541
     do so for executables, and we definitely don't want anyone
4542
     dlopening executables.  */
4543
  if (entry->relocstlsoff)
4544
    dinfo->info->flags |= DF_STATIC_TLS;
4545
 
4546
  /* Allocate space for a TLS descriptor.  */
4547
  if (entry->tlsdesc12)
4548
    dinfo->tlsd12 += 8 * l;
4549
  else if (entry->tlsdesclos)
4550
    dinfo->tlsdlos += 8 * l;
4551
  else if (entry->tlsplt)
4552
    dinfo->tlsdplt += 8 * l;
4553
  else if (entry->tlsdeschilo)
4554
    dinfo->tlsdhilo += 8 * l;
4555
  else
4556
    entry->relocstlsd -= l;
4557
  entry->relocstlsd += l;
4558
}
4559
 
4560
/* Compute the number of dynamic relocations and fixups that a symbol
4561
   requires, and add (or subtract) from the grand and per-symbol
4562
   totals.  */
4563
 
4564
static void
4565
_frvfdpic_count_relocs_fixups (struct frvfdpic_relocs_info *entry,
4566
                               struct _frvfdpic_dynamic_got_info *dinfo,
4567
                               bfd_boolean subtract)
4568
{
4569
  bfd_vma relocs = 0, fixups = 0, tlsrets = 0;
4570
 
4571
  if (!dinfo->info->executable || dinfo->info->pie)
4572
    {
4573
      relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv
4574
        + entry->relocstlsd;
4575
 
4576
      /* In the executable, TLS relocations to symbols that bind
4577
         locally (including those that resolve to global TLS offsets)
4578
         are resolved immediately, without any need for fixups or
4579
         dynamic relocations.  In shared libraries, however, we must
4580
         emit dynamic relocations even for local symbols, because we
4581
         don't know the module id the library is going to get at
4582
         run-time, nor its TLS base offset.  */
4583
      if (!dinfo->info->executable
4584
          || (entry->symndx == -1
4585
              && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4586
        relocs += entry->relocstlsoff;
4587
    }
4588
  else
4589
    {
4590
      if (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
4591
        {
4592
          if (entry->symndx != -1
4593
              || entry->d.h->root.type != bfd_link_hash_undefweak)
4594
            fixups += entry->relocs32 + 2 * entry->relocsfdv;
4595
          fixups += entry->relocstlsd;
4596
          tlsrets += entry->relocstlsd;
4597
        }
4598
      else
4599
        {
4600
          relocs += entry->relocs32 + entry->relocsfdv
4601
            + entry->relocstlsoff + entry->relocstlsd;
4602
        }
4603
 
4604
      if (entry->symndx != -1
4605
          || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
4606
        {
4607
          if (entry->symndx != -1
4608
              || entry->d.h->root.type != bfd_link_hash_undefweak)
4609
            fixups += entry->relocsfd;
4610
        }
4611
      else
4612
        relocs += entry->relocsfd;
4613
    }
4614
 
4615
  if (subtract)
4616
    {
4617
      relocs = - relocs;
4618
      fixups = - fixups;
4619
      tlsrets = - tlsrets;
4620
    }
4621
 
4622
  entry->dynrelocs += relocs;
4623
  entry->fixups += fixups;
4624
  dinfo->relocs += relocs;
4625
  dinfo->fixups += fixups;
4626
  dinfo->tls_ret_refs += tlsrets;
4627
}
4628
 
4629
/* Look for opportunities to relax TLS relocations.  We can assume
4630
   we're linking the main executable or a static-tls library, since
4631
   otherwise we wouldn't have got here.  When relaxing, we have to
4632
   first undo any previous accounting of TLS uses of fixups, dynamic
4633
   relocations, GOT and PLT entries.  */
4634
 
4635
static void
4636
_frvfdpic_relax_tls_entries (struct frvfdpic_relocs_info *entry,
4637
                             struct _frvfdpic_dynamic_got_info *dinfo,
4638
                             bfd_boolean relaxing)
4639
{
4640
  bfd_boolean changed = ! relaxing;
4641
 
4642
  BFD_ASSERT (dinfo->info->executable
4643
              || (dinfo->info->flags & DF_STATIC_TLS));
4644
 
4645
  if (entry->tlsdesc12 || entry->tlsdesclos || entry->tlsdeschilo)
4646
    {
4647
      if (! changed)
4648
        {
4649
          _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4650
          _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4651
          changed = TRUE;
4652
        }
4653
 
4654
      /* When linking an executable, we can always decay GOTTLSDESC to
4655
         TLSMOFF, if the symbol is local, or GOTTLSOFF, otherwise.
4656
         When linking a static-tls shared library, using TLSMOFF is
4657
         not an option, but we can still use GOTTLSOFF.  When decaying
4658
         to GOTTLSOFF, we must keep the GOT entry in range.  We know
4659
         it has to fit because we'll be trading the 4 words of hte TLS
4660
         descriptor for a single word in the same range.  */
4661
      if (! dinfo->info->executable
4662
          || (entry->symndx == -1
4663
              && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4664
        {
4665
          entry->tlsoff12 |= entry->tlsdesc12;
4666
          entry->tlsofflos |= entry->tlsdesclos;
4667
          entry->tlsoffhilo |= entry->tlsdeschilo;
4668
        }
4669
 
4670
      entry->tlsdesc12 = entry->tlsdesclos = entry->tlsdeschilo = 0;
4671
    }
4672
 
4673
  /* We can only decay TLSOFFs or call #gettlsoff to TLSMOFF in the
4674
     main executable.  We have to check whether the symbol's TLSOFF is
4675
     in range for a setlos.  For symbols with a hash entry, we can
4676
     determine exactly what to do; for others locals, we don't have
4677
     addresses handy, so we use the size of the TLS section as an
4678
     approximation.  If we get it wrong, we'll retain a GOT entry
4679
     holding the TLS offset (without dynamic relocations or fixups),
4680
     but we'll still optimize away the loads from it.  Since TLS sizes
4681
     are generally very small, it's probably not worth attempting to
4682
     do better than this.  */
4683
  if ((entry->tlsplt
4684
       || entry->tlsoff12 || entry->tlsofflos || entry->tlsoffhilo)
4685
      && dinfo->info->executable && relaxing
4686
      && ((entry->symndx == -1
4687
           && FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4688
           /* The above may hold for an undefweak TLS symbol, so make
4689
              sure we don't have this case before accessing def.value
4690
              and def.section.  */
4691
           && (entry->d.h->root.type == bfd_link_hash_undefweak
4692
               || (bfd_vma)(entry->d.h->root.u.def.value
4693
                            + (entry->d.h->root.u.def.section
4694
                               ->output_section->vma)
4695
                            + entry->d.h->root.u.def.section->output_offset
4696
                            + entry->addend
4697
                            - tls_biased_base (dinfo->info)
4698
                            + 32768) < (bfd_vma)65536))
4699
          || (entry->symndx != -1
4700
              && (elf_hash_table (dinfo->info)->tls_sec->size
4701
                  + abs (entry->addend) < 32768 + FRVFDPIC_TLS_BIAS))))
4702
    {
4703
      if (! changed)
4704
        {
4705
          _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4706
          _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4707
          changed = TRUE;
4708
        }
4709
 
4710
      entry->tlsplt =
4711
        entry->tlsoff12 = entry->tlsofflos = entry->tlsoffhilo = 0;
4712
    }
4713
 
4714
  /* We can decay `call #gettlsoff' to a ldi #tlsoff if we already
4715
     have a #gottlsoff12 relocation for this entry, or if we can fit
4716
     one more in the 12-bit (and 16-bit) ranges.  */
4717
  if (entry->tlsplt
4718
      && (entry->tlsoff12
4719
          || (relaxing
4720
              && dinfo->got12 + dinfo->fd12 + dinfo->tlsd12 <= 4096 - 12 - 4
4721
              && (dinfo->got12 + dinfo->fd12 + dinfo->tlsd12
4722
                  + dinfo->gotlos + dinfo->fdlos + dinfo->tlsdlos
4723
                  <= 65536 - 12 - 4))))
4724
    {
4725
      if (! changed)
4726
        {
4727
          _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4728
          _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4729
          changed = TRUE;
4730
        }
4731
 
4732
      entry->tlsoff12 = 1;
4733
      entry->tlsplt = 0;
4734
    }
4735
 
4736
  if (changed)
4737
    {
4738
      _frvfdpic_count_tls_entries (entry, dinfo, FALSE);
4739
      _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE);
4740
    }
4741
 
4742
  return;
4743
}
4744
 
4745
/* Compute the total GOT and PLT size required by each symbol in each range. *
4746
   Symbols may require up to 4 words in the GOT: an entry pointing to
4747
   the symbol, an entry pointing to its function descriptor, and a
4748
   private function descriptors taking two words.  */
4749
 
4750
static int
4751
_frvfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
4752
{
4753
  struct frvfdpic_relocs_info *entry = *entryp;
4754
  struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
4755
 
4756
  _frvfdpic_count_nontls_entries (entry, dinfo);
4757
 
4758
  if (dinfo->info->executable || (dinfo->info->flags & DF_STATIC_TLS))
4759
    _frvfdpic_relax_tls_entries (entry, dinfo, FALSE);
4760
  else
4761
    {
4762
      _frvfdpic_count_tls_entries (entry, dinfo, FALSE);
4763
      _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE);
4764
    }
4765
 
4766
  return 1;
4767
}
4768
 
4769
/* Determine the positive and negative ranges to be used by each
4770
   offset range in the GOT.  FDCUR and CUR, that must be aligned to a
4771
   double-word boundary, are the minimum (negative) and maximum
4772
   (positive) GOT offsets already used by previous ranges, except for
4773
   an ODD entry that may have been left behind.  GOT and FD indicate
4774
   the size of GOT entries and function descriptors that must be
4775
   placed within the range from -WRAP to WRAP.  If there's room left,
4776
   up to FDPLT bytes should be reserved for additional function
4777
   descriptors.  */
4778
 
4779
inline static bfd_signed_vma
4780
_frvfdpic_compute_got_alloc_data (struct _frvfdpic_dynamic_got_alloc_data *gad,
4781
                                  bfd_signed_vma fdcur,
4782
                                  bfd_signed_vma odd,
4783
                                  bfd_signed_vma cur,
4784
                                  bfd_vma got,
4785
                                  bfd_vma fd,
4786
                                  bfd_vma fdplt,
4787
                                  bfd_vma tlsd,
4788
                                  bfd_vma tlsdplt,
4789
                                  bfd_vma wrap)
4790
{
4791
  bfd_signed_vma wrapmin = -wrap;
4792
  const bfd_vma tdescsz = 8;
4793
 
4794
  /* Start at the given initial points.  */
4795
  gad->fdcur = fdcur;
4796
  gad->cur = cur;
4797
 
4798
  /* If we had an incoming odd word and we have any got entries that
4799
     are going to use it, consume it, otherwise leave gad->odd at
4800
     zero.  We might force gad->odd to zero and return the incoming
4801
     odd such that it is used by the next range, but then GOT entries
4802
     might appear to be out of order and we wouldn't be able to
4803
     shorten the GOT by one word if it turns out to end with an
4804
     unpaired GOT entry.  */
4805
  if (odd && got)
4806
    {
4807
      gad->odd = odd;
4808
      got -= 4;
4809
      odd = 0;
4810
    }
4811
  else
4812
    gad->odd = 0;
4813
 
4814
  /* If we're left with an unpaired GOT entry, compute its location
4815
     such that we can return it.  Otherwise, if got doesn't require an
4816
     odd number of words here, either odd was already zero in the
4817
     block above, or it was set to zero because got was non-zero, or
4818
     got was already zero.  In the latter case, we want the value of
4819
     odd to carry over to the return statement, so we don't want to
4820
     reset odd unless the condition below is true.  */
4821
  if (got & 4)
4822
    {
4823
      odd = cur + got;
4824
      got += 4;
4825
    }
4826
 
4827
  /* Compute the tentative boundaries of this range.  */
4828
  gad->max = cur + got;
4829
  gad->min = fdcur - fd;
4830
  gad->fdplt = 0;
4831
 
4832
  /* If function descriptors took too much space, wrap some of them
4833
     around.  */
4834
  if (gad->min < wrapmin)
4835
    {
4836
      gad->max += wrapmin - gad->min;
4837
      gad->tmin = gad->min = wrapmin;
4838
    }
4839
 
4840
  /* If GOT entries took too much space, wrap some of them around.
4841
     This may well cause gad->min to become lower than wrapmin.  This
4842
     will cause a relocation overflow later on, so we don't have to
4843
     report it here . */
4844
  if ((bfd_vma) gad->max > wrap)
4845
    {
4846
      gad->min -= gad->max - wrap;
4847
      gad->max = wrap;
4848
    }
4849
 
4850
  /* Add TLS descriptors.  */
4851
  gad->tmax = gad->max + tlsd;
4852
  gad->tmin = gad->min;
4853
  gad->tlsdplt = 0;
4854
 
4855
  /* If TLS descriptors took too much space, wrap an integral number
4856
     of them around.  */
4857
  if ((bfd_vma) gad->tmax > wrap)
4858
    {
4859
      bfd_vma wrapsize = gad->tmax - wrap;
4860
 
4861
      wrapsize += tdescsz / 2;
4862
      wrapsize &= ~ tdescsz / 2;
4863
 
4864
      gad->tmin -= wrapsize;
4865
      gad->tmax -= wrapsize;
4866
    }
4867
 
4868
  /* If there is space left and we have function descriptors
4869
     referenced in PLT entries that could take advantage of shorter
4870
     offsets, place them now.  */
4871
  if (fdplt && gad->tmin > wrapmin)
4872
    {
4873
      bfd_vma fds;
4874
 
4875
      if ((bfd_vma) (gad->tmin - wrapmin) < fdplt)
4876
        fds = gad->tmin - wrapmin;
4877
      else
4878
        fds = fdplt;
4879
 
4880
      fdplt -= fds;
4881
      gad->min -= fds;
4882
      gad->tmin -= fds;
4883
      gad->fdplt += fds;
4884
    }
4885
 
4886
  /* If there is more space left, try to place some more function
4887
     descriptors for PLT entries.  */
4888
  if (fdplt && (bfd_vma) gad->tmax < wrap)
4889
    {
4890
      bfd_vma fds;
4891
 
4892
      if ((bfd_vma) (wrap - gad->tmax) < fdplt)
4893
        fds = wrap - gad->tmax;
4894
      else
4895
        fds = fdplt;
4896
 
4897
      fdplt -= fds;
4898
      gad->max += fds;
4899
      gad->tmax += fds;
4900
      gad->fdplt += fds;
4901
    }
4902
 
4903
  /* If there is space left and we have TLS descriptors referenced in
4904
     PLT entries that could take advantage of shorter offsets, place
4905
     them now.  */
4906
  if (tlsdplt && gad->tmin > wrapmin)
4907
    {
4908
      bfd_vma tlsds;
4909
 
4910
      if ((bfd_vma) (gad->tmin - wrapmin) < tlsdplt)
4911
        tlsds = (gad->tmin - wrapmin) & ~ (tdescsz / 2);
4912
      else
4913
        tlsds = tlsdplt;
4914
 
4915
      tlsdplt -= tlsds;
4916
      gad->tmin -= tlsds;
4917
      gad->tlsdplt += tlsds;
4918
    }
4919
 
4920
  /* If there is more space left, try to place some more TLS
4921
     descriptors for PLT entries.  Although we could try to fit an
4922
     additional TLS descriptor with half of it just before before the
4923
     wrap point and another right past the wrap point, this might
4924
     cause us to run out of space for the next region, so don't do
4925
     it.  */
4926
  if (tlsdplt && (bfd_vma) gad->tmax < wrap - tdescsz / 2)
4927
    {
4928
      bfd_vma tlsds;
4929
 
4930
      if ((bfd_vma) (wrap - gad->tmax) < tlsdplt)
4931
        tlsds = (wrap - gad->tmax) & ~ (tdescsz / 2);
4932
      else
4933
        tlsds = tlsdplt;
4934
 
4935
      tlsdplt -= tlsds;
4936
      gad->tmax += tlsds;
4937
      gad->tlsdplt += tlsds;
4938
    }
4939
 
4940
  /* If odd was initially computed as an offset past the wrap point,
4941
     wrap it around.  */
4942
  if (odd > gad->max)
4943
    odd = gad->min + odd - gad->max;
4944
 
4945
  /* _frvfdpic_get_got_entry() below will always wrap gad->cur if needed
4946
     before returning, so do it here too.  This guarantees that,
4947
     should cur and fdcur meet at the wrap point, they'll both be
4948
     equal to min.  */
4949
  if (gad->cur == gad->max)
4950
    gad->cur = gad->min;
4951
 
4952
  /* Ditto for _frvfdpic_get_tlsdesc_entry().  */
4953
  gad->tcur = gad->max;
4954
  if (gad->tcur == gad->tmax)
4955
    gad->tcur = gad->tmin;
4956
 
4957
  return odd;
4958
}
4959
 
4960
/* Compute the location of the next GOT entry, given the allocation
4961
   data for a range.  */
4962
 
4963
inline static bfd_signed_vma
4964
_frvfdpic_get_got_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
4965
{
4966
  bfd_signed_vma ret;
4967
 
4968
  if (gad->odd)
4969
    {
4970
      /* If there was an odd word left behind, use it.  */
4971
      ret = gad->odd;
4972
      gad->odd = 0;
4973
    }
4974
  else
4975
    {
4976
      /* Otherwise, use the word pointed to by cur, reserve the next
4977
         as an odd word, and skip to the next pair of words, possibly
4978
         wrapping around.  */
4979
      ret = gad->cur;
4980
      gad->odd = gad->cur + 4;
4981
      gad->cur += 8;
4982
      if (gad->cur == gad->max)
4983
        gad->cur = gad->min;
4984
    }
4985
 
4986
  return ret;
4987
}
4988
 
4989
/* Compute the location of the next function descriptor entry in the
4990
   GOT, given the allocation data for a range.  */
4991
 
4992
inline static bfd_signed_vma
4993
_frvfdpic_get_fd_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
4994
{
4995
  /* If we're at the bottom, wrap around, and only then allocate the
4996
     next pair of words.  */
4997
  if (gad->fdcur == gad->min)
4998
    gad->fdcur = gad->max;
4999
  return gad->fdcur -= 8;
5000
}
5001
 
5002
/* Compute the location of the next TLS descriptor entry in the GOT,
5003
   given the allocation data for a range.  */
5004
inline static bfd_signed_vma
5005
_frvfdpic_get_tlsdesc_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
5006
{
5007
  bfd_signed_vma ret;
5008
 
5009
  ret = gad->tcur;
5010
 
5011
  gad->tcur += 8;
5012
 
5013
  /* If we're at the top of the region, wrap around to the bottom.  */
5014
  if (gad->tcur == gad->tmax)
5015
    gad->tcur = gad->tmin;
5016
 
5017
  return ret;
5018
}
5019
 
5020
/* Assign GOT offsets for every GOT entry and function descriptor.
5021
   Doing everything in a single pass is tricky.  */
5022
 
5023
static int
5024
_frvfdpic_assign_got_entries (void **entryp, void *info_)
5025
{
5026
  struct frvfdpic_relocs_info *entry = *entryp;
5027
  struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
5028
 
5029
  if (entry->got12)
5030
    entry->got_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5031
  else if (entry->gotlos)
5032
    entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5033
  else if (entry->gothilo)
5034
    entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5035
 
5036
  if (entry->fdgot12)
5037
    entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5038
  else if (entry->fdgotlos)
5039
    entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5040
  else if (entry->fdgothilo)
5041
    entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5042
 
5043
  if (entry->fdgoff12)
5044
    entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
5045
  else if (entry->plt && dinfo->got12.fdplt)
5046
    {
5047
      dinfo->got12.fdplt -= 8;
5048
      entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
5049
    }
5050
  else if (entry->fdgofflos)
5051
    entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
5052
  else if (entry->plt && dinfo->gotlos.fdplt)
5053
    {
5054
      dinfo->gotlos.fdplt -= 8;
5055
      entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
5056
    }
5057
  else if (entry->plt)
5058
    {
5059
      dinfo->gothilo.fdplt -= 8;
5060
      entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5061
    }
5062
  else if (entry->privfd)
5063
    entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5064
 
5065
  if (entry->tlsoff12)
5066
    entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5067
  else if (entry->tlsofflos)
5068
    entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5069
  else if (entry->tlsoffhilo)
5070
    entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5071
 
5072
  if (entry->tlsdesc12)
5073
    entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5074
  else if (entry->tlsplt && dinfo->got12.tlsdplt)
5075
    {
5076
      dinfo->got12.tlsdplt -= 8;
5077
      entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5078
    }
5079
  else if (entry->tlsdesclos)
5080
    entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5081
  else if (entry->tlsplt && dinfo->gotlos.tlsdplt)
5082
    {
5083
      dinfo->gotlos.tlsdplt -= 8;
5084
      entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5085
    }
5086
  else if (entry->tlsplt)
5087
    {
5088
      dinfo->gothilo.tlsdplt -= 8;
5089
      entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5090
    }
5091
  else if (entry->tlsdeschilo)
5092
    entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5093
 
5094
  return 1;
5095
}
5096
 
5097
/* Assign GOT offsets to private function descriptors used by PLT
5098
   entries (or referenced by 32-bit offsets), as well as PLT entries
5099
   and lazy PLT entries.  */
5100
 
5101
static int
5102
_frvfdpic_assign_plt_entries (void **entryp, void *info_)
5103
{
5104
  struct frvfdpic_relocs_info *entry = *entryp;
5105
  struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
5106
 
5107
  if (entry->privfd)
5108
    BFD_ASSERT (entry->fd_entry);
5109
 
5110
  if (entry->plt)
5111
    {
5112
      int size;
5113
 
5114
      /* We use the section's raw size to mark the location of the
5115
         next PLT entry.  */
5116
      entry->plt_entry = frvfdpic_plt_section (dinfo->g.info)->size;
5117
 
5118
      /* Figure out the length of this PLT entry based on the
5119
         addressing mode we need to reach the function descriptor.  */
5120
      BFD_ASSERT (entry->fd_entry);
5121
      if (entry->fd_entry >= -(1 << (12 - 1))
5122
          && entry->fd_entry < (1 << (12 - 1)))
5123
        size = 8;
5124
      else if (entry->fd_entry >= -(1 << (16 - 1))
5125
               && entry->fd_entry < (1 << (16 - 1)))
5126
        size = 12;
5127
      else
5128
        size = 16;
5129
 
5130
      frvfdpic_plt_section (dinfo->g.info)->size += size;
5131
    }
5132
 
5133
  if (entry->lazyplt)
5134
    {
5135
      entry->lzplt_entry = dinfo->g.lzplt;
5136
      dinfo->g.lzplt += 8;
5137
      /* If this entry is the one that gets the resolver stub, account
5138
         for the additional instruction.  */
5139
      if (entry->lzplt_entry % FRVFDPIC_LZPLT_BLOCK_SIZE
5140
          == FRVFDPIC_LZPLT_RESOLV_LOC)
5141
        dinfo->g.lzplt += 4;
5142
    }
5143
 
5144
  if (entry->tlsplt)
5145
    {
5146
      int size;
5147
 
5148
      entry->tlsplt_entry
5149
        = frvfdpic_plt_section (dinfo->g.info)->size;
5150
 
5151
      if (dinfo->g.info->executable
5152
          && (entry->symndx != -1
5153
              || FRVFDPIC_SYM_LOCAL (dinfo->g.info, entry->d.h)))
5154
        {
5155
          if ((bfd_signed_vma)entry->addend >= -(1 << (16 - 1))
5156
              /* FIXME: here we use the size of the TLS section
5157
                 as an upper bound for the value of the TLS
5158
                 symbol, because we may not know the exact value
5159
                 yet.  If we get it wrong, we'll just waste a
5160
                 word in the PLT, and we should never get even
5161
                 close to 32 KiB of TLS anyway.  */
5162
              && elf_hash_table (dinfo->g.info)->tls_sec
5163
              && (elf_hash_table (dinfo->g.info)->tls_sec->size
5164
                  + (bfd_signed_vma)(entry->addend) <= (1 << (16 - 1))))
5165
            size = 8;
5166
          else
5167
            size = 12;
5168
        }
5169
      else if (entry->tlsoff_entry)
5170
        {
5171
          if (entry->tlsoff_entry >= -(1 << (12 - 1))
5172
              && entry->tlsoff_entry < (1 << (12 - 1)))
5173
            size = 8;
5174
          else if (entry->tlsoff_entry >= -(1 << (16 - 1))
5175
                   && entry->tlsoff_entry < (1 << (16 - 1)))
5176
            size = 12;
5177
          else
5178
            size = 16;
5179
        }
5180
      else
5181
        {
5182
          BFD_ASSERT (entry->tlsdesc_entry);
5183
 
5184
          if (entry->tlsdesc_entry >= -(1 << (12 - 1))
5185
              && entry->tlsdesc_entry < (1 << (12 - 1)))
5186
            size = 8;
5187
          else if (entry->tlsdesc_entry >= -(1 << (16 - 1))
5188
                   && entry->tlsdesc_entry < (1 << (16 - 1)))
5189
            size = 12;
5190
          else
5191
            size = 16;
5192
        }
5193
 
5194
      frvfdpic_plt_section (dinfo->g.info)->size += size;
5195
    }
5196
 
5197
  return 1;
5198
}
5199
 
5200
/* Cancel out any effects of calling _frvfdpic_assign_got_entries and
5201
   _frvfdpic_assign_plt_entries.  */
5202
 
5203
static int
5204
_frvfdpic_reset_got_plt_entries (void **entryp, void *ignore ATTRIBUTE_UNUSED)
5205
{
5206
  struct frvfdpic_relocs_info *entry = *entryp;
5207
 
5208
  entry->got_entry = 0;
5209
  entry->fdgot_entry = 0;
5210
  entry->fd_entry = 0;
5211
  entry->plt_entry = (bfd_vma)-1;
5212
  entry->lzplt_entry = (bfd_vma)-1;
5213
  entry->tlsoff_entry = 0;
5214
  entry->tlsdesc_entry = 0;
5215
  entry->tlsplt_entry = (bfd_vma)-1;
5216
 
5217
  return 1;
5218
}
5219
 
5220
/* Follow indirect and warning hash entries so that each got entry
5221
   points to the final symbol definition.  P must point to a pointer
5222
   to the hash table we're traversing.  Since this traversal may
5223
   modify the hash table, we set this pointer to NULL to indicate
5224
   we've made a potentially-destructive change to the hash table, so
5225
   the traversal must be restarted.  */
5226
static int
5227
_frvfdpic_resolve_final_relocs_info (void **entryp, void *p)
5228
{
5229
  struct frvfdpic_relocs_info *entry = *entryp;
5230
  htab_t *htab = p;
5231
 
5232
  if (entry->symndx == -1)
5233
    {
5234
      struct elf_link_hash_entry *h = entry->d.h;
5235
      struct frvfdpic_relocs_info *oentry;
5236
 
5237
      while (h->root.type == bfd_link_hash_indirect
5238
             || h->root.type == bfd_link_hash_warning)
5239
        h = (struct elf_link_hash_entry *)h->root.u.i.link;
5240
 
5241
      if (entry->d.h == h)
5242
        return 1;
5243
 
5244
      oentry = frvfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
5245
                                                NO_INSERT);
5246
 
5247
      if (oentry)
5248
        {
5249
          /* Merge the two entries.  */
5250
          frvfdpic_pic_merge_early_relocs_info (oentry, entry);
5251
          htab_clear_slot (*htab, entryp);
5252
          return 1;
5253
        }
5254
 
5255
      entry->d.h = h;
5256
 
5257
      /* If we can't find this entry with the new bfd hash, re-insert
5258
         it, and get the traversal restarted.  */
5259
      if (! htab_find (*htab, entry))
5260
        {
5261
          htab_clear_slot (*htab, entryp);
5262
          entryp = htab_find_slot (*htab, entry, INSERT);
5263
          if (! *entryp)
5264
            *entryp = entry;
5265
          /* Abort the traversal, since the whole table may have
5266
             moved, and leave it up to the parent to restart the
5267
             process.  */
5268
          *(htab_t *)p = NULL;
5269
          return 0;
5270
        }
5271
    }
5272
 
5273
  return 1;
5274
}
5275
 
5276
/* Compute the total size of the GOT, the PLT, the dynamic relocations
5277
   section and the rofixup section.  Assign locations for GOT and PLT
5278
   entries.  */
5279
 
5280
static bfd_boolean
5281
_frvfdpic_size_got_plt (bfd *output_bfd,
5282
                        struct _frvfdpic_dynamic_got_plt_info *gpinfop)
5283
{
5284
  bfd_signed_vma odd;
5285
  bfd_vma limit, tlslimit;
5286
  struct bfd_link_info *info = gpinfop->g.info;
5287
  bfd *dynobj = elf_hash_table (info)->dynobj;
5288
 
5289
  memcpy (frvfdpic_dynamic_got_plt_info (info), &gpinfop->g,
5290
          sizeof (gpinfop->g));
5291
 
5292
  odd = 12;
5293
  /* Compute the total size taken by entries in the 12-bit and 16-bit
5294
     ranges, to tell how many PLT function descriptors we can bring
5295
     into the 12-bit range without causing the 16-bit range to
5296
     overflow.  */
5297
  limit = odd + gpinfop->g.got12 + gpinfop->g.gotlos
5298
    + gpinfop->g.fd12 + gpinfop->g.fdlos
5299
    + gpinfop->g.tlsd12 + gpinfop->g.tlsdlos;
5300
  if (limit < (bfd_vma)1 << 16)
5301
    limit = ((bfd_vma)1 << 16) - limit;
5302
  else
5303
    limit = 0;
5304
  if (gpinfop->g.fdplt < limit)
5305
    {
5306
      tlslimit = (limit - gpinfop->g.fdplt) & ~ (bfd_vma) 8;
5307
      limit = gpinfop->g.fdplt;
5308
    }
5309
  else
5310
    tlslimit = 0;
5311
  if (gpinfop->g.tlsdplt < tlslimit)
5312
    tlslimit = gpinfop->g.tlsdplt;
5313
 
5314
  /* Determine the ranges of GOT offsets that we can use for each
5315
     range of addressing modes.  */
5316
  odd = _frvfdpic_compute_got_alloc_data (&gpinfop->got12,
5317
                                          0,
5318
                                          odd,
5319
                                          16,
5320
                                          gpinfop->g.got12,
5321
                                          gpinfop->g.fd12,
5322
                                          limit,
5323
                                          gpinfop->g.tlsd12,
5324
                                          tlslimit,
5325
                                          (bfd_vma)1 << (12-1));
5326
  odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gotlos,
5327
                                          gpinfop->got12.tmin,
5328
                                          odd,
5329
                                          gpinfop->got12.tmax,
5330
                                          gpinfop->g.gotlos,
5331
                                          gpinfop->g.fdlos,
5332
                                          gpinfop->g.fdplt
5333
                                          - gpinfop->got12.fdplt,
5334
                                          gpinfop->g.tlsdlos,
5335
                                          gpinfop->g.tlsdplt
5336
                                          - gpinfop->got12.tlsdplt,
5337
                                          (bfd_vma)1 << (16-1));
5338
  odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gothilo,
5339
                                          gpinfop->gotlos.tmin,
5340
                                          odd,
5341
                                          gpinfop->gotlos.tmax,
5342
                                          gpinfop->g.gothilo,
5343
                                          gpinfop->g.fdhilo,
5344
                                          gpinfop->g.fdplt
5345
                                          - gpinfop->got12.fdplt
5346
                                          - gpinfop->gotlos.fdplt,
5347
                                          gpinfop->g.tlsdhilo,
5348
                                          gpinfop->g.tlsdplt
5349
                                          - gpinfop->got12.tlsdplt
5350
                                          - gpinfop->gotlos.tlsdplt,
5351
                                          (bfd_vma)1 << (32-1));
5352
 
5353
  /* Now assign (most) GOT offsets.  */
5354
  htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_got_entries,
5355
                 gpinfop);
5356
 
5357
  frvfdpic_got_section (info)->size = gpinfop->gothilo.tmax
5358
    - gpinfop->gothilo.tmin
5359
    /* If an odd word is the last word of the GOT, we don't need this
5360
       word to be part of the GOT.  */
5361
    - (odd + 4 == gpinfop->gothilo.tmax ? 4 : 0);
5362
  if (frvfdpic_got_section (info)->size == 0)
5363
    frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
5364
  else if (frvfdpic_got_section (info)->size == 12
5365
           && ! elf_hash_table (info)->dynamic_sections_created)
5366
    {
5367
      frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
5368
      frvfdpic_got_section (info)->size = 0;
5369
    }
5370
  /* This will be non-NULL during relaxation.  The assumption is that
5371
     the size of one of these sections will never grow, only shrink,
5372
     so we can use the larger buffer we allocated before.  */
5373
  else if (frvfdpic_got_section (info)->contents == NULL)
5374
    {
5375
      frvfdpic_got_section (info)->contents =
5376
        (bfd_byte *) bfd_zalloc (dynobj,
5377
                                 frvfdpic_got_section (info)->size);
5378
      if (frvfdpic_got_section (info)->contents == NULL)
5379
        return FALSE;
5380
    }
5381
 
5382
  if (frvfdpic_gotrel_section (info))
5383
    /* Subtract the number of lzplt entries, since those will generate
5384
       relocations in the pltrel section.  */
5385
    frvfdpic_gotrel_section (info)->size =
5386
      (gpinfop->g.relocs - gpinfop->g.lzplt / 8)
5387
      * get_elf_backend_data (output_bfd)->s->sizeof_rel;
5388
  else
5389
    BFD_ASSERT (gpinfop->g.relocs == 0);
5390
  if (frvfdpic_gotrel_section (info)->size == 0)
5391
    frvfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
5392
  else if (frvfdpic_gotrel_section (info)->contents == NULL)
5393
    {
5394
      frvfdpic_gotrel_section (info)->contents =
5395
        (bfd_byte *) bfd_zalloc (dynobj,
5396
                                 frvfdpic_gotrel_section (info)->size);
5397
      if (frvfdpic_gotrel_section (info)->contents == NULL)
5398
        return FALSE;
5399
    }
5400
 
5401
  frvfdpic_gotfixup_section (info)->size = (gpinfop->g.fixups + 1) * 4;
5402
  if (frvfdpic_gotfixup_section (info)->size == 0)
5403
    frvfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
5404
  else if (frvfdpic_gotfixup_section (info)->contents == NULL)
5405
    {
5406
      frvfdpic_gotfixup_section (info)->contents =
5407
        (bfd_byte *) bfd_zalloc (dynobj,
5408
                                 frvfdpic_gotfixup_section (info)->size);
5409
      if (frvfdpic_gotfixup_section (info)->contents == NULL)
5410
        return FALSE;
5411
    }
5412
 
5413
  if (frvfdpic_pltrel_section (info))
5414
    {
5415
      frvfdpic_pltrel_section (info)->size =
5416
        gpinfop->g.lzplt / 8
5417
        * get_elf_backend_data (output_bfd)->s->sizeof_rel;
5418
      if (frvfdpic_pltrel_section (info)->size == 0)
5419
        frvfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
5420
      else if (frvfdpic_pltrel_section (info)->contents == NULL)
5421
        {
5422
          frvfdpic_pltrel_section (info)->contents =
5423
            (bfd_byte *) bfd_zalloc (dynobj,
5424
                                     frvfdpic_pltrel_section (info)->size);
5425
          if (frvfdpic_pltrel_section (info)->contents == NULL)
5426
            return FALSE;
5427
        }
5428
    }
5429
 
5430
  /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
5431
     such that there's room for the additional instruction needed to
5432
     call the resolver.  Since _frvfdpic_assign_got_entries didn't
5433
     account for them, our block size is 4 bytes smaller than the real
5434
     block size.  */
5435
  if (frvfdpic_plt_section (info))
5436
    {
5437
      frvfdpic_plt_section (info)->size = gpinfop->g.lzplt
5438
        + ((gpinfop->g.lzplt + (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) - 8)
5439
           / (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) * 4);
5440
    }
5441
 
5442
  /* Reset it, such that _frvfdpic_assign_plt_entries() can use it to
5443
     actually assign lazy PLT entries addresses.  */
5444
  gpinfop->g.lzplt = 0;
5445
 
5446
  /* Save information that we're going to need to generate GOT and PLT
5447
     entries.  */
5448
  frvfdpic_got_initial_offset (info) = -gpinfop->gothilo.tmin;
5449
 
5450
  if (get_elf_backend_data (output_bfd)->want_got_sym)
5451
    elf_hash_table (info)->hgot->root.u.def.value
5452
      = frvfdpic_got_initial_offset (info);
5453
 
5454
  if (frvfdpic_plt_section (info))
5455
    frvfdpic_plt_initial_offset (info) =
5456
      frvfdpic_plt_section (info)->size;
5457
 
5458
  /* Allocate a ret statement at plt_initial_offset, to be used by
5459
     locally-resolved TLS descriptors.  */
5460
  if (gpinfop->g.tls_ret_refs)
5461
    frvfdpic_plt_section (info)->size += 4;
5462
 
5463
  htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_plt_entries,
5464
                 gpinfop);
5465
 
5466
  /* Allocate the PLT section contents only after
5467
     _frvfdpic_assign_plt_entries has a chance to add the size of the
5468
     non-lazy PLT entries.  */
5469
  if (frvfdpic_plt_section (info))
5470
    {
5471
      if (frvfdpic_plt_section (info)->size == 0)
5472
        frvfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
5473
      else if (frvfdpic_plt_section (info)->contents == NULL)
5474
        {
5475
          frvfdpic_plt_section (info)->contents =
5476
            (bfd_byte *) bfd_zalloc (dynobj,
5477
                                     frvfdpic_plt_section (info)->size);
5478
          if (frvfdpic_plt_section (info)->contents == NULL)
5479
            return FALSE;
5480
        }
5481
    }
5482
 
5483
  return TRUE;
5484
}
5485
 
5486
/* Set the sizes of the dynamic sections.  */
5487
 
5488
static bfd_boolean
5489
elf32_frvfdpic_size_dynamic_sections (bfd *output_bfd,
5490
                                      struct bfd_link_info *info)
5491
{
5492
  bfd *dynobj;
5493
  asection *s;
5494
  struct _frvfdpic_dynamic_got_plt_info gpinfo;
5495
 
5496
  dynobj = elf_hash_table (info)->dynobj;
5497
  BFD_ASSERT (dynobj != NULL);
5498
 
5499
  if (elf_hash_table (info)->dynamic_sections_created)
5500
    {
5501
      /* Set the contents of the .interp section to the interpreter.  */
5502
      if (info->executable)
5503
        {
5504
          s = bfd_get_section_by_name (dynobj, ".interp");
5505
          BFD_ASSERT (s != NULL);
5506
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5507
          s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
5508
        }
5509
    }
5510
 
5511
  memset (&gpinfo, 0, sizeof (gpinfo));
5512
  gpinfo.g.info = info;
5513
 
5514
  for (;;)
5515
    {
5516
      htab_t relocs = frvfdpic_relocs_info (info);
5517
 
5518
      htab_traverse (relocs, _frvfdpic_resolve_final_relocs_info, &relocs);
5519
 
5520
      if (relocs == frvfdpic_relocs_info (info))
5521
        break;
5522
    }
5523
 
5524
  htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_count_got_plt_entries,
5525
                 &gpinfo.g);
5526
 
5527
  /* Allocate space to save the summary information, we're going to
5528
     use it if we're doing relaxations.  */
5529
  frvfdpic_dynamic_got_plt_info (info) = bfd_alloc (dynobj, sizeof (gpinfo.g));
5530
 
5531
  if (!_frvfdpic_size_got_plt (output_bfd, &gpinfo))
5532
    return FALSE;
5533
 
5534
  if (elf_hash_table (info)->dynamic_sections_created)
5535
    {
5536
      if (frvfdpic_got_section (info)->size)
5537
        if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
5538
          return FALSE;
5539
 
5540
      if (frvfdpic_pltrel_section (info)->size)
5541
        if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
5542
            || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
5543
            || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
5544
          return FALSE;
5545
 
5546
      if (frvfdpic_gotrel_section (info)->size)
5547
        if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
5548
            || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
5549
            || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
5550
                                            sizeof (Elf32_External_Rel)))
5551
          return FALSE;
5552
    }
5553
 
5554
  return TRUE;
5555
}
5556
 
5557
static bfd_boolean
5558
elf32_frvfdpic_always_size_sections (bfd *output_bfd,
5559
                                     struct bfd_link_info *info)
5560
{
5561
  if (!info->relocatable)
5562
    {
5563
      struct elf_link_hash_entry *h;
5564
 
5565
      /* Force a PT_GNU_STACK segment to be created.  */
5566
      if (! elf_tdata (output_bfd)->stack_flags)
5567
        elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
5568
 
5569
      /* Define __stacksize if it's not defined yet.  */
5570
      h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
5571
                                FALSE, FALSE, FALSE);
5572
      if (! h || h->root.type != bfd_link_hash_defined
5573
          || h->type != STT_OBJECT
5574
          || !h->def_regular)
5575
        {
5576
          struct bfd_link_hash_entry *bh = NULL;
5577
 
5578
          if (!(_bfd_generic_link_add_one_symbol
5579
                (info, output_bfd, "__stacksize",
5580
                 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
5581
                 (const char *) NULL, FALSE,
5582
                 get_elf_backend_data (output_bfd)->collect, &bh)))
5583
            return FALSE;
5584
 
5585
          h = (struct elf_link_hash_entry *) bh;
5586
          h->def_regular = 1;
5587
          h->type = STT_OBJECT;
5588
          /* This one must NOT be hidden.  */
5589
        }
5590
    }
5591
 
5592
  return TRUE;
5593
}
5594
 
5595
/* Check whether any of the relocations was optimized away, and
5596
   subtract it from the relocation or fixup count.  */
5597
static bfd_boolean
5598
_frvfdpic_check_discarded_relocs (bfd *abfd, asection *sec,
5599
                                  struct bfd_link_info *info,
5600
 
5601
                                  bfd_boolean *changed)
5602
{
5603
  Elf_Internal_Shdr *symtab_hdr;
5604
  struct elf_link_hash_entry **sym_hashes;
5605
  Elf_Internal_Rela *rel, *erel;
5606
 
5607
  if ((sec->flags & SEC_RELOC) == 0
5608
      || sec->reloc_count == 0)
5609
    return TRUE;
5610
 
5611
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5612
  sym_hashes = elf_sym_hashes (abfd);
5613
 
5614
  rel = elf_section_data (sec)->relocs;
5615
 
5616
  /* Now examine each relocation.  */
5617
  for (erel = rel + sec->reloc_count; rel < erel; rel++)
5618
    {
5619
      struct elf_link_hash_entry *h;
5620
      unsigned long r_symndx;
5621
      struct frvfdpic_relocs_info *picrel;
5622
      struct _frvfdpic_dynamic_got_info *dinfo;
5623
 
5624
      if (ELF32_R_TYPE (rel->r_info) != R_FRV_32
5625
          && ELF32_R_TYPE (rel->r_info) != R_FRV_FUNCDESC)
5626
        continue;
5627
 
5628
      if (_bfd_elf_section_offset (sec->output_section->owner,
5629
                                   info, sec, rel->r_offset)
5630
          != (bfd_vma)-1)
5631
        continue;
5632
 
5633
      r_symndx = ELF32_R_SYM (rel->r_info);
5634
      if (r_symndx < symtab_hdr->sh_info)
5635
        h = NULL;
5636
      else
5637
        {
5638
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5639
          while (h->root.type == bfd_link_hash_indirect
5640
                 || h->root.type == bfd_link_hash_warning)
5641
            h = (struct elf_link_hash_entry *)h->root.u.i.link;
5642
        }
5643
 
5644
      if (h != NULL)
5645
        picrel = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info),
5646
                                                  abfd, h,
5647
                                                  rel->r_addend, NO_INSERT);
5648
      else
5649
        picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info (info),
5650
                                                 abfd, r_symndx,
5651
                                                 rel->r_addend, NO_INSERT);
5652
 
5653
      if (! picrel)
5654
        return FALSE;
5655
 
5656
      *changed = TRUE;
5657
      dinfo = frvfdpic_dynamic_got_plt_info (info);
5658
 
5659
      _frvfdpic_count_relocs_fixups (picrel, dinfo, TRUE);
5660
      if (ELF32_R_TYPE (rel->r_info) == R_FRV_32)
5661
        picrel->relocs32--;
5662
      else /* we know (ELF32_R_TYPE (rel->r_info) == R_FRV_FUNCDESC) */
5663
        picrel->relocsfd--;
5664
      _frvfdpic_count_relocs_fixups (picrel, dinfo, FALSE);
5665
    }
5666
 
5667
  return TRUE;
5668
}
5669
 
5670
static bfd_boolean
5671
frvfdpic_elf_discard_info (bfd *ibfd,
5672
                           struct elf_reloc_cookie *cookie ATTRIBUTE_UNUSED,
5673
                           struct bfd_link_info *info)
5674
{
5675
  bfd_boolean changed = FALSE;
5676
  asection *s;
5677
  bfd *obfd = NULL;
5678
 
5679
  /* Account for relaxation of .eh_frame section.  */
5680
  for (s = ibfd->sections; s; s = s->next)
5681
    if (s->sec_info_type == ELF_INFO_TYPE_EH_FRAME)
5682
      {
5683
        if (!_frvfdpic_check_discarded_relocs (ibfd, s, info, &changed))
5684
          return FALSE;
5685
        obfd = s->output_section->owner;
5686
      }
5687
 
5688
  if (changed)
5689
    {
5690
      struct _frvfdpic_dynamic_got_plt_info gpinfo;
5691
 
5692
      memset (&gpinfo, 0, sizeof (gpinfo));
5693
      memcpy (&gpinfo.g, frvfdpic_dynamic_got_plt_info (info),
5694
              sizeof (gpinfo.g));
5695
 
5696
      /* Clear GOT and PLT assignments.  */
5697
      htab_traverse (frvfdpic_relocs_info (info),
5698
                     _frvfdpic_reset_got_plt_entries,
5699
                     NULL);
5700
 
5701
      if (!_frvfdpic_size_got_plt (obfd, &gpinfo))
5702
        return FALSE;
5703
    }
5704
 
5705
  return TRUE;
5706
}
5707
 
5708
/* Look for opportunities to relax TLS relocations.  We can assume
5709
   we're linking the main executable or a static-tls library, since
5710
   otherwise we wouldn't have got here.  */
5711
 
5712
static int
5713
_frvfdpic_relax_got_plt_entries (void **entryp, void *dinfo_)
5714
{
5715
  struct frvfdpic_relocs_info *entry = *entryp;
5716
  struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
5717
 
5718
  _frvfdpic_relax_tls_entries (entry, dinfo, TRUE);
5719
 
5720
  return 1;
5721
}
5722
 
5723
static bfd_boolean
5724
elf32_frvfdpic_relax_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
5725
                              struct bfd_link_info *info, bfd_boolean *again)
5726
{
5727
  struct _frvfdpic_dynamic_got_plt_info gpinfo;
5728
 
5729
  if (info->relocatable)
5730
    (*info->callbacks->einfo)
5731
      (_("%P%F: --relax and -r may not be used together\n"));
5732
 
5733
  /* If we return early, we didn't change anything.  */
5734
  *again = FALSE;
5735
 
5736
  /* We'll do our thing when requested to relax the GOT section.  */
5737
  if (sec != frvfdpic_got_section (info))
5738
    return TRUE;
5739
 
5740
  /* We can only relax when linking the main executable or a library
5741
     that can't be dlopened.  */
5742
  if (! info->executable && ! (info->flags & DF_STATIC_TLS))
5743
    return TRUE;
5744
 
5745
  /* If there isn't a TLS section for this binary, we can't do
5746
     anything about its TLS relocations (it probably doesn't have
5747
     any.  */
5748
  if (elf_hash_table (info)->tls_sec == NULL)
5749
    return TRUE;
5750
 
5751
  memset (&gpinfo, 0, sizeof (gpinfo));
5752
  memcpy (&gpinfo.g, frvfdpic_dynamic_got_plt_info (info), sizeof (gpinfo.g));
5753
 
5754
  /* Now look for opportunities to relax, adjusting the GOT usage
5755
     as needed.  */
5756
  htab_traverse (frvfdpic_relocs_info (info),
5757
                 _frvfdpic_relax_got_plt_entries,
5758
                 &gpinfo.g);
5759
 
5760
  /* If we changed anything, reset and re-assign GOT and PLT entries.  */
5761
  if (memcmp (frvfdpic_dynamic_got_plt_info (info),
5762
              &gpinfo.g, sizeof (gpinfo.g)) != 0)
5763
    {
5764
      /* Clear GOT and PLT assignments.  */
5765
      htab_traverse (frvfdpic_relocs_info (info),
5766
                     _frvfdpic_reset_got_plt_entries,
5767
                     NULL);
5768
 
5769
      /* The owner of the TLS section is the output bfd.  There should
5770
         be a better way to get to it.  */
5771
      if (!_frvfdpic_size_got_plt (elf_hash_table (info)->tls_sec->owner,
5772
                                   &gpinfo))
5773
        return FALSE;
5774
 
5775
      /* Repeat until we don't make any further changes.  We could fail to
5776
         introduce changes in a round if, for example, the 12-bit range is
5777
         full, but we later release some space by getting rid of TLS
5778
         descriptors in it.  We have to repeat the whole process because
5779
         we might have changed the size of a section processed before this
5780
         one.  */
5781
      *again = TRUE;
5782
    }
5783
 
5784
  return TRUE;
5785
}
5786
 
5787
static bfd_boolean
5788
elf32_frvfdpic_modify_program_headers (bfd *output_bfd,
5789
                                       struct bfd_link_info *info)
5790
{
5791
  struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
5792
  struct elf_segment_map *m;
5793
  Elf_Internal_Phdr *p;
5794
 
5795
  /* objcopy and strip preserve what's already there using
5796
     elf32_frvfdpic_copy_private_bfd_data ().  */
5797
  if (! info)
5798
    return TRUE;
5799
 
5800
  for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
5801
    if (m->p_type == PT_GNU_STACK)
5802
      break;
5803
 
5804
  if (m)
5805
    {
5806
      struct elf_link_hash_entry *h;
5807
 
5808
      /* Obtain the pointer to the __stacksize symbol.  */
5809
      h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
5810
                                FALSE, FALSE, FALSE);
5811
      if (h)
5812
        {
5813
          while (h->root.type == bfd_link_hash_indirect
5814
                 || h->root.type == bfd_link_hash_warning)
5815
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
5816
          BFD_ASSERT (h->root.type == bfd_link_hash_defined);
5817
        }
5818
 
5819
      /* Set the header p_memsz from the symbol value.  We
5820
         intentionally ignore the symbol section.  */
5821
      if (h && h->root.type == bfd_link_hash_defined)
5822
        p->p_memsz = h->root.u.def.value;
5823
      else
5824
        p->p_memsz = DEFAULT_STACK_SIZE;
5825
 
5826
      p->p_align = 8;
5827
    }
5828
 
5829
  return TRUE;
5830
}
5831
 
5832
/* Fill in code and data in dynamic sections.  */
5833
 
5834
static bfd_boolean
5835
elf32_frv_finish_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5836
                                   struct bfd_link_info *info ATTRIBUTE_UNUSED)
5837
{
5838
  /* Nothing to be done for non-FDPIC.  */
5839
  return TRUE;
5840
}
5841
 
5842
static bfd_boolean
5843
elf32_frvfdpic_finish_dynamic_sections (bfd *output_bfd,
5844
                                        struct bfd_link_info *info)
5845
{
5846
  bfd *dynobj;
5847
  asection *sdyn;
5848
 
5849
  dynobj = elf_hash_table (info)->dynobj;
5850
 
5851
  if (frvfdpic_dynamic_got_plt_info (info))
5852
    {
5853
      BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs == 0);
5854
    }
5855
  if (frvfdpic_got_section (info))
5856
    {
5857
      BFD_ASSERT (frvfdpic_gotrel_section (info)->size
5858
                  == (frvfdpic_gotrel_section (info)->reloc_count
5859
                      * sizeof (Elf32_External_Rel)));
5860
 
5861
      if (frvfdpic_gotfixup_section (info))
5862
        {
5863
          struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
5864
          bfd_vma got_value = hgot->root.u.def.value
5865
            + hgot->root.u.def.section->output_section->vma
5866
            + hgot->root.u.def.section->output_offset;
5867
          struct bfd_link_hash_entry *hend;
5868
 
5869
          _frvfdpic_add_rofixup (output_bfd, frvfdpic_gotfixup_section (info),
5870
                                 got_value, 0);
5871
 
5872
          if (frvfdpic_gotfixup_section (info)->size
5873
              != (frvfdpic_gotfixup_section (info)->reloc_count * 4))
5874
            {
5875
            error:
5876
              info->callbacks->einfo
5877
                ("LINKER BUG: .rofixup section size mismatch\n");
5878
              return FALSE;
5879
            }
5880
 
5881
          hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
5882
                                       FALSE, FALSE, TRUE);
5883
          if (hend
5884
              && (hend->type == bfd_link_hash_defined
5885
                  || hend->type == bfd_link_hash_defweak)
5886
              && hend->u.def.section->output_section != NULL)
5887
            {
5888
              bfd_vma value =
5889
                frvfdpic_gotfixup_section (info)->output_section->vma
5890
                + frvfdpic_gotfixup_section (info)->output_offset
5891
                + frvfdpic_gotfixup_section (info)->size
5892
                - hend->u.def.section->output_section->vma
5893
                - hend->u.def.section->output_offset;
5894
              BFD_ASSERT (hend->u.def.value == value);
5895
              if (hend->u.def.value != value)
5896
                goto error;
5897
            }
5898
        }
5899
    }
5900
  if (frvfdpic_pltrel_section (info))
5901
    {
5902
      BFD_ASSERT (frvfdpic_pltrel_section (info)->size
5903
                  == (frvfdpic_pltrel_section (info)->reloc_count
5904
                      * sizeof (Elf32_External_Rel)));
5905
    }
5906
 
5907
 
5908
  if (elf_hash_table (info)->dynamic_sections_created)
5909
    {
5910
      Elf32_External_Dyn * dyncon;
5911
      Elf32_External_Dyn * dynconend;
5912
 
5913
      sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5914
 
5915
      BFD_ASSERT (sdyn != NULL);
5916
 
5917
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
5918
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5919
 
5920
      for (; dyncon < dynconend; dyncon++)
5921
        {
5922
          Elf_Internal_Dyn dyn;
5923
 
5924
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5925
 
5926
          switch (dyn.d_tag)
5927
            {
5928
            default:
5929
              break;
5930
 
5931
            case DT_PLTGOT:
5932
              dyn.d_un.d_ptr = frvfdpic_got_section (info)->output_section->vma
5933
                + frvfdpic_got_section (info)->output_offset
5934
                + frvfdpic_got_initial_offset (info);
5935
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5936
              break;
5937
 
5938
            case DT_JMPREL:
5939
              dyn.d_un.d_ptr = frvfdpic_pltrel_section (info)
5940
                ->output_section->vma
5941
                + frvfdpic_pltrel_section (info)->output_offset;
5942
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5943
              break;
5944
 
5945
            case DT_PLTRELSZ:
5946
              dyn.d_un.d_val = frvfdpic_pltrel_section (info)->size;
5947
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5948
              break;
5949
            }
5950
        }
5951
    }
5952
 
5953
  return TRUE;
5954
}
5955
 
5956
/* Adjust a symbol defined by a dynamic object and referenced by a
5957
   regular object.  */
5958
 
5959
static bfd_boolean
5960
elf32_frvfdpic_adjust_dynamic_symbol
5961
(struct bfd_link_info *info ATTRIBUTE_UNUSED,
5962
 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
5963
{
5964
  bfd * dynobj;
5965
 
5966
  dynobj = elf_hash_table (info)->dynobj;
5967
 
5968
  /* Make sure we know what is going on here.  */
5969
  BFD_ASSERT (dynobj != NULL
5970
              && (h->u.weakdef != NULL
5971
                  || (h->def_dynamic
5972
                      && h->ref_regular
5973
                      && !h->def_regular)));
5974
 
5975
  /* If this is a weak symbol, and there is a real definition, the
5976
     processor independent code will have arranged for us to see the
5977
     real definition first, and we can just use the same value.  */
5978
  if (h->u.weakdef != NULL)
5979
    {
5980
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5981
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
5982
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
5983
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
5984
    }
5985
 
5986
  return TRUE;
5987
}
5988
 
5989
/* Perform any actions needed for dynamic symbols.  */
5990
 
5991
static bfd_boolean
5992
elf32_frvfdpic_finish_dynamic_symbol
5993
(bfd *output_bfd ATTRIBUTE_UNUSED,
5994
 struct bfd_link_info *info ATTRIBUTE_UNUSED,
5995
 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
5996
 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
5997
{
5998
  return TRUE;
5999
}
6000
 
6001
/* Decide whether to attempt to turn absptr or lsda encodings in
6002
   shared libraries into pcrel within the given input section.  */
6003
 
6004
static bfd_boolean
6005
frvfdpic_elf_use_relative_eh_frame
6006
(bfd *input_bfd ATTRIBUTE_UNUSED,
6007
 struct bfd_link_info *info ATTRIBUTE_UNUSED,
6008
 asection *eh_frame_section ATTRIBUTE_UNUSED)
6009
{
6010
  /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
6011
  return FALSE;
6012
}
6013
 
6014
/* Adjust the contents of an eh_frame_hdr section before they're output.  */
6015
 
6016
static bfd_byte
6017
frvfdpic_elf_encode_eh_address (bfd *abfd,
6018
                                struct bfd_link_info *info,
6019
                                asection *osec, bfd_vma offset,
6020
                                asection *loc_sec, bfd_vma loc_offset,
6021
                                bfd_vma *encoded)
6022
{
6023
  struct elf_link_hash_entry *h;
6024
 
6025
  h = elf_hash_table (info)->hgot;
6026
  BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
6027
 
6028
  if (! h || (_frvfdpic_osec_to_segment (abfd, osec)
6029
              == _frvfdpic_osec_to_segment (abfd, loc_sec->output_section)))
6030
    return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
6031
                                       loc_sec, loc_offset, encoded);
6032
 
6033
  BFD_ASSERT (_frvfdpic_osec_to_segment (abfd, osec)
6034
              == (_frvfdpic_osec_to_segment
6035
                  (abfd, h->root.u.def.section->output_section)));
6036
 
6037
  *encoded = osec->vma + offset
6038
    - (h->root.u.def.value
6039
       + h->root.u.def.section->output_section->vma
6040
       + h->root.u.def.section->output_offset);
6041
 
6042
  return DW_EH_PE_datarel | DW_EH_PE_sdata4;
6043
}
6044
 
6045
/* Look through the relocs for a section during the first phase.
6046
 
6047
   Besides handling virtual table relocs for gc, we have to deal with
6048
   all sorts of PIC-related relocations.  We describe below the
6049
   general plan on how to handle such relocations, even though we only
6050
   collect information at this point, storing them in hash tables for
6051
   perusal of later passes.
6052
 
6053
   32 relocations are propagated to the linker output when creating
6054
   position-independent output.  LO16 and HI16 relocations are not
6055
   supposed to be encountered in this case.
6056
 
6057
   LABEL16 should always be resolvable by the linker, since it's only
6058
   used by branches.
6059
 
6060
   LABEL24, on the other hand, is used by calls.  If it turns out that
6061
   the target of a call is a dynamic symbol, a PLT entry must be
6062
   created for it, which triggers the creation of a private function
6063
   descriptor and, unless lazy binding is disabled, a lazy PLT entry.
6064
 
6065
   GPREL relocations require the referenced symbol to be in the same
6066
   segment as _gp, but this can only be checked later.
6067
 
6068
   All GOT, GOTOFF and FUNCDESC relocations require a .got section to
6069
   exist.  LABEL24 might as well, since it may require a PLT entry,
6070
   that will require a got.
6071
 
6072
   Non-FUNCDESC GOT relocations require a GOT entry to be created
6073
   regardless of whether the symbol is dynamic.  However, since a
6074
   global symbol that turns out to not be exported may have the same
6075
   address of a non-dynamic symbol, we don't assign GOT entries at
6076
   this point, such that we can share them in this case.  A relocation
6077
   for the GOT entry always has to be created, be it to offset a
6078
   private symbol by the section load address, be it to get the symbol
6079
   resolved dynamically.
6080
 
6081
   FUNCDESC GOT relocations require a GOT entry to be created, and
6082
   handled as if a FUNCDESC relocation was applied to the GOT entry in
6083
   an object file.
6084
 
6085
   FUNCDESC relocations referencing a symbol that turns out to NOT be
6086
   dynamic cause a private function descriptor to be created.  The
6087
   FUNCDESC relocation then decays to a 32 relocation that points at
6088
   the private descriptor.  If the symbol is dynamic, the FUNCDESC
6089
   relocation is propagated to the linker output, such that the
6090
   dynamic linker creates the canonical descriptor, pointing to the
6091
   dynamically-resolved definition of the function.
6092
 
6093
   Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
6094
   symbols that are assigned to the same segment as the GOT, but we
6095
   can only check this later, after we know the complete set of
6096
   symbols defined and/or exported.
6097
 
6098
   FUNCDESC GOTOFF relocations require a function descriptor to be
6099
   created and, unless lazy binding is disabled or the symbol is not
6100
   dynamic, a lazy PLT entry.  Since we can't tell at this point
6101
   whether a symbol is going to be dynamic, we have to decide later
6102
   whether to create a lazy PLT entry or bind the descriptor directly
6103
   to the private function.
6104
 
6105
   FUNCDESC_VALUE relocations are not supposed to be present in object
6106
   files, but they may very well be simply propagated to the linker
6107
   output, since they have no side effect.
6108
 
6109
 
6110
   A function descriptor always requires a FUNCDESC_VALUE relocation.
6111
   Whether it's in .plt.rel or not depends on whether lazy binding is
6112
   enabled and on whether the referenced symbol is dynamic.
6113
 
6114
   The existence of a lazy PLT requires the resolverStub lazy PLT
6115
   entry to be present.
6116
 
6117
 
6118
   As for assignment of GOT, PLT and lazy PLT entries, and private
6119
   descriptors, we might do them all sequentially, but we can do
6120
   better than that.  For example, we can place GOT entries and
6121
   private function descriptors referenced using 12-bit operands
6122
   closer to the PIC register value, such that these relocations don't
6123
   overflow.  Those that are only referenced with LO16 relocations
6124
   could come next, but we may as well place PLT-required function
6125
   descriptors in the 12-bit range to make them shorter.  Symbols
6126
   referenced with LO16/HI16 may come next, but we may place
6127
   additional function descriptors in the 16-bit range if we can
6128
   reliably tell that we've already placed entries that are ever
6129
   referenced with only LO16.  PLT entries are therefore generated as
6130
   small as possible, while not introducing relocation overflows in
6131
   GOT or FUNCDESC_GOTOFF relocations.  Lazy PLT entries could be
6132
   generated before or after PLT entries, but not intermingled with
6133
   them, such that we can have more lazy PLT entries in range for a
6134
   branch to the resolverStub.  The resolverStub should be emitted at
6135
   the most distant location from the first lazy PLT entry such that
6136
   it's still in range for a branch, or closer, if there isn't a need
6137
   for so many lazy PLT entries.  Additional lazy PLT entries may be
6138
   emitted after the resolverStub, as long as branches are still in
6139
   range.  If the branch goes out of range, longer lazy PLT entries
6140
   are emitted.
6141
 
6142
   We could further optimize PLT and lazy PLT entries by giving them
6143
   priority in assignment to closer-to-gr17 locations depending on the
6144
   number of occurrences of references to them (assuming a function
6145
   that's called more often is more important for performance, so its
6146
   PLT entry should be faster), or taking hints from the compiler.
6147
   Given infinite time and money... :-)  */
6148
 
6149
static bfd_boolean
6150
elf32_frv_check_relocs (abfd, info, sec, relocs)
6151
     bfd *abfd;
6152
     struct bfd_link_info *info;
6153
     asection *sec;
6154
     const Elf_Internal_Rela *relocs;
6155
{
6156
  Elf_Internal_Shdr *symtab_hdr;
6157
  struct elf_link_hash_entry **sym_hashes;
6158
  const Elf_Internal_Rela *rel;
6159
  const Elf_Internal_Rela *rel_end;
6160
  bfd *dynobj;
6161
  struct frvfdpic_relocs_info *picrel;
6162
 
6163
  if (info->relocatable)
6164
    return TRUE;
6165
 
6166
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6167
  sym_hashes = elf_sym_hashes (abfd);
6168
 
6169
  dynobj = elf_hash_table (info)->dynobj;
6170
  rel_end = relocs + sec->reloc_count;
6171
  for (rel = relocs; rel < rel_end; rel++)
6172
    {
6173
      struct elf_link_hash_entry *h;
6174
      unsigned long r_symndx;
6175
 
6176
      r_symndx = ELF32_R_SYM (rel->r_info);
6177
      if (r_symndx < symtab_hdr->sh_info)
6178
        h = NULL;
6179
      else
6180
        {
6181
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6182
          while (h->root.type == bfd_link_hash_indirect
6183
                 || h->root.type == bfd_link_hash_warning)
6184
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
6185
        }
6186
 
6187
      switch (ELF32_R_TYPE (rel->r_info))
6188
        {
6189
        case R_FRV_GETTLSOFF:
6190
        case R_FRV_TLSDESC_VALUE:
6191
        case R_FRV_GOTTLSDESC12:
6192
        case R_FRV_GOTTLSDESCHI:
6193
        case R_FRV_GOTTLSDESCLO:
6194
        case R_FRV_GOTTLSOFF12:
6195
        case R_FRV_GOTTLSOFFHI:
6196
        case R_FRV_GOTTLSOFFLO:
6197
        case R_FRV_TLSOFF:
6198
        case R_FRV_GOT12:
6199
        case R_FRV_GOTHI:
6200
        case R_FRV_GOTLO:
6201
        case R_FRV_FUNCDESC_GOT12:
6202
        case R_FRV_FUNCDESC_GOTHI:
6203
        case R_FRV_FUNCDESC_GOTLO:
6204
        case R_FRV_GOTOFF12:
6205
        case R_FRV_GOTOFFHI:
6206
        case R_FRV_GOTOFFLO:
6207
        case R_FRV_FUNCDESC_GOTOFF12:
6208
        case R_FRV_FUNCDESC_GOTOFFHI:
6209
        case R_FRV_FUNCDESC_GOTOFFLO:
6210
        case R_FRV_FUNCDESC:
6211
        case R_FRV_FUNCDESC_VALUE:
6212
        case R_FRV_TLSMOFF12:
6213
        case R_FRV_TLSMOFFHI:
6214
        case R_FRV_TLSMOFFLO:
6215
        case R_FRV_TLSMOFF:
6216
          if (! IS_FDPIC (abfd))
6217
            goto bad_reloc;
6218
          /* Fall through.  */
6219
        case R_FRV_GPREL12:
6220
        case R_FRV_GPRELU12:
6221
        case R_FRV_GPRELHI:
6222
        case R_FRV_GPRELLO:
6223
        case R_FRV_LABEL24:
6224
        case R_FRV_32:
6225
          if (! dynobj)
6226
            {
6227
              elf_hash_table (info)->dynobj = dynobj = abfd;
6228
              if (! _frv_create_got_section (abfd, info))
6229
                return FALSE;
6230
            }
6231
          if (! IS_FDPIC (abfd))
6232
            {
6233
              picrel = NULL;
6234
              break;
6235
            }
6236
          if (h != NULL)
6237
            {
6238
              if (h->dynindx == -1)
6239
                switch (ELF_ST_VISIBILITY (h->other))
6240
                  {
6241
                  case STV_INTERNAL:
6242
                  case STV_HIDDEN:
6243
                    break;
6244
                  default:
6245
                    bfd_elf_link_record_dynamic_symbol (info, h);
6246
                    break;
6247
                  }
6248
              picrel
6249
                = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info),
6250
                                                   abfd, h,
6251
                                                   rel->r_addend, INSERT);
6252
            }
6253
          else
6254
            picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
6255
                                                     (info), abfd, r_symndx,
6256
                                                     rel->r_addend, INSERT);
6257
          if (! picrel)
6258
            return FALSE;
6259
          break;
6260
 
6261
        default:
6262
          picrel = NULL;
6263
          break;
6264
        }
6265
 
6266
      switch (ELF32_R_TYPE (rel->r_info))
6267
        {
6268
        case R_FRV_LABEL24:
6269
          if (IS_FDPIC (abfd))
6270
            picrel->call = 1;
6271
          break;
6272
 
6273
        case R_FRV_FUNCDESC_VALUE:
6274
          picrel->relocsfdv++;
6275
          if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
6276
            picrel->relocs32--;
6277
          /* Fall through.  */
6278
 
6279
        case R_FRV_32:
6280
          if (! IS_FDPIC (abfd))
6281
            break;
6282
 
6283
          picrel->sym = 1;
6284
          if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
6285
            picrel->relocs32++;
6286
          break;
6287
 
6288
        case R_FRV_GOT12:
6289
          picrel->got12 = 1;
6290
          break;
6291
 
6292
        case R_FRV_GOTHI:
6293
        case R_FRV_GOTLO:
6294
          picrel->gothilo = 1;
6295
          break;
6296
 
6297
        case R_FRV_FUNCDESC_GOT12:
6298
          picrel->fdgot12 = 1;
6299
          break;
6300
 
6301
        case R_FRV_FUNCDESC_GOTHI:
6302
        case R_FRV_FUNCDESC_GOTLO:
6303
          picrel->fdgothilo = 1;
6304
          break;
6305
 
6306
        case R_FRV_GOTOFF12:
6307
        case R_FRV_GOTOFFHI:
6308
        case R_FRV_GOTOFFLO:
6309
          picrel->gotoff = 1;
6310
          break;
6311
 
6312
        case R_FRV_FUNCDESC_GOTOFF12:
6313
          picrel->fdgoff12 = 1;
6314
          break;
6315
 
6316
        case R_FRV_FUNCDESC_GOTOFFHI:
6317
        case R_FRV_FUNCDESC_GOTOFFLO:
6318
          picrel->fdgoffhilo = 1;
6319
          break;
6320
 
6321
        case R_FRV_FUNCDESC:
6322
          picrel->fd = 1;
6323
          picrel->relocsfd++;
6324
          break;
6325
 
6326
        case R_FRV_GETTLSOFF:
6327
          picrel->tlsplt = 1;
6328
          break;
6329
 
6330
        case R_FRV_TLSDESC_VALUE:
6331
          picrel->relocstlsd++;
6332
          goto bad_reloc;
6333
 
6334
        case R_FRV_GOTTLSDESC12:
6335
          picrel->tlsdesc12 = 1;
6336
          break;
6337
 
6338
        case R_FRV_GOTTLSDESCHI:
6339
        case R_FRV_GOTTLSDESCLO:
6340
          picrel->tlsdeschilo = 1;
6341
          break;
6342
 
6343
        case R_FRV_TLSMOFF12:
6344
        case R_FRV_TLSMOFFHI:
6345
        case R_FRV_TLSMOFFLO:
6346
        case R_FRV_TLSMOFF:
6347
          break;
6348
 
6349
        case R_FRV_GOTTLSOFF12:
6350
          picrel->tlsoff12 = 1;
6351
          info->flags |= DF_STATIC_TLS;
6352
          break;
6353
 
6354
        case R_FRV_GOTTLSOFFHI:
6355
        case R_FRV_GOTTLSOFFLO:
6356
          picrel->tlsoffhilo = 1;
6357
          info->flags |= DF_STATIC_TLS;
6358
          break;
6359
 
6360
        case R_FRV_TLSOFF:
6361
          picrel->relocstlsoff++;
6362
          info->flags |= DF_STATIC_TLS;
6363
          goto bad_reloc;
6364
 
6365
        /* This relocation describes the C++ object vtable hierarchy.
6366
           Reconstruct it for later use during GC.  */
6367
        case R_FRV_GNU_VTINHERIT:
6368
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6369
            return FALSE;
6370
          break;
6371
 
6372
        /* This relocation describes which C++ vtable entries are actually
6373
           used.  Record for later use during GC.  */
6374
        case R_FRV_GNU_VTENTRY:
6375
          BFD_ASSERT (h != NULL);
6376
          if (h != NULL
6377
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6378
            return FALSE;
6379
          break;
6380
 
6381
        case R_FRV_LABEL16:
6382
        case R_FRV_LO16:
6383
        case R_FRV_HI16:
6384
        case R_FRV_GPREL12:
6385
        case R_FRV_GPRELU12:
6386
        case R_FRV_GPREL32:
6387
        case R_FRV_GPRELHI:
6388
        case R_FRV_GPRELLO:
6389
        case R_FRV_TLSDESC_RELAX:
6390
        case R_FRV_GETTLSOFF_RELAX:
6391
        case R_FRV_TLSOFF_RELAX:
6392
          break;
6393
 
6394
        default:
6395
        bad_reloc:
6396
          info->callbacks->einfo
6397
            (_("%B: unsupported relocation type %i\n"),
6398
             abfd, ELF32_R_TYPE (rel->r_info));
6399
          return FALSE;
6400
        }
6401
    }
6402
 
6403
  return TRUE;
6404
}
6405
 
6406
 
6407
/* Return the machine subcode from the ELF e_flags header.  */
6408
 
6409
static int
6410
elf32_frv_machine (abfd)
6411
     bfd *abfd;
6412
{
6413
  switch (elf_elfheader (abfd)->e_flags & EF_FRV_CPU_MASK)
6414
    {
6415
    default:                break;
6416
    case EF_FRV_CPU_FR550:  return bfd_mach_fr550;
6417
    case EF_FRV_CPU_FR500:  return bfd_mach_fr500;
6418
    case EF_FRV_CPU_FR450:  return bfd_mach_fr450;
6419
    case EF_FRV_CPU_FR405:  return bfd_mach_fr400;
6420
    case EF_FRV_CPU_FR400:  return bfd_mach_fr400;
6421
    case EF_FRV_CPU_FR300:  return bfd_mach_fr300;
6422
    case EF_FRV_CPU_SIMPLE: return bfd_mach_frvsimple;
6423
    case EF_FRV_CPU_TOMCAT: return bfd_mach_frvtomcat;
6424
    }
6425
 
6426
  return bfd_mach_frv;
6427
}
6428
 
6429
/* Set the right machine number for a FRV ELF file.  */
6430
 
6431
static bfd_boolean
6432
elf32_frv_object_p (abfd)
6433
     bfd *abfd;
6434
{
6435
  bfd_default_set_arch_mach (abfd, bfd_arch_frv, elf32_frv_machine (abfd));
6436
  return (((elf_elfheader (abfd)->e_flags & EF_FRV_FDPIC) != 0)
6437
          == (IS_FDPIC (abfd)));
6438
}
6439
 
6440
/* Function to set the ELF flag bits.  */
6441
 
6442
static bfd_boolean
6443
frv_elf_set_private_flags (abfd, flags)
6444
     bfd *abfd;
6445
     flagword flags;
6446
{
6447
  elf_elfheader (abfd)->e_flags = flags;
6448
  elf_flags_init (abfd) = TRUE;
6449
  return TRUE;
6450
}
6451
 
6452
/* Copy backend specific data from one object module to another.  */
6453
 
6454
static bfd_boolean
6455
frv_elf_copy_private_bfd_data (ibfd, obfd)
6456
     bfd *ibfd;
6457
     bfd *obfd;
6458
{
6459
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6460
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6461
    return TRUE;
6462
 
6463
  BFD_ASSERT (!elf_flags_init (obfd)
6464
              || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
6465
 
6466
  elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6467
  elf_flags_init (obfd) = TRUE;
6468
 
6469
  /* Copy object attributes.  */
6470
  _bfd_elf_copy_obj_attributes (ibfd, obfd);
6471
 
6472
  return TRUE;
6473
}
6474
 
6475
/* Return true if the architecture described by elf header flag
6476
   EXTENSION is an extension of the architecture described by BASE.  */
6477
 
6478
static bfd_boolean
6479
frv_elf_arch_extension_p (flagword base, flagword extension)
6480
{
6481
  if (base == extension)
6482
    return TRUE;
6483
 
6484
  /* CPU_GENERIC code can be merged with code for a specific
6485
     architecture, in which case the result is marked as being
6486
     for the specific architecture.  Everything is therefore
6487
     an extension of CPU_GENERIC.  */
6488
  if (base == EF_FRV_CPU_GENERIC)
6489
    return TRUE;
6490
 
6491
  if (extension == EF_FRV_CPU_FR450)
6492
    if (base == EF_FRV_CPU_FR400 || base == EF_FRV_CPU_FR405)
6493
      return TRUE;
6494
 
6495
  if (extension == EF_FRV_CPU_FR405)
6496
    if (base == EF_FRV_CPU_FR400)
6497
      return TRUE;
6498
 
6499
  return FALSE;
6500
}
6501
 
6502
static bfd_boolean
6503
elf32_frvfdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
6504
{
6505
  unsigned i;
6506
 
6507
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6508
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6509
    return TRUE;
6510
 
6511
  if (! frv_elf_copy_private_bfd_data (ibfd, obfd))
6512
    return FALSE;
6513
 
6514
  if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
6515
      || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
6516
    return TRUE;
6517
 
6518
  /* Copy the stack size.  */
6519
  for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
6520
    if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
6521
      {
6522
        Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
6523
 
6524
        for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
6525
          if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
6526
            {
6527
              memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
6528
 
6529
              /* Rewrite the phdrs, since we're only called after they
6530
                 were first written.  */
6531
              if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
6532
                            ->s->sizeof_ehdr, SEEK_SET) != 0
6533
                  || get_elf_backend_data (obfd)->s
6534
                  ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
6535
                                     elf_elfheader (obfd)->e_phnum) != 0)
6536
                return FALSE;
6537
              break;
6538
            }
6539
 
6540
        break;
6541
      }
6542
 
6543
  return TRUE;
6544
}
6545
 
6546
/* Merge backend specific data from an object file to the output
6547
   object file when linking.  */
6548
 
6549
static bfd_boolean
6550
frv_elf_merge_private_bfd_data (ibfd, obfd)
6551
     bfd *ibfd;
6552
     bfd *obfd;
6553
{
6554
  flagword old_flags, old_partial;
6555
  flagword new_flags, new_partial;
6556
  bfd_boolean error = FALSE;
6557
  char new_opt[80];
6558
  char old_opt[80];
6559
 
6560
  new_opt[0] = old_opt[0] = '\0';
6561
  new_flags = elf_elfheader (ibfd)->e_flags;
6562
  old_flags = elf_elfheader (obfd)->e_flags;
6563
 
6564
  if (new_flags & EF_FRV_FDPIC)
6565
    new_flags &= ~EF_FRV_PIC;
6566
 
6567
#ifdef DEBUG
6568
  (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
6569
                         old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
6570
                         bfd_get_filename (ibfd));
6571
#endif
6572
 
6573
  if (!elf_flags_init (obfd))                   /* First call, no flags set.  */
6574
    {
6575
      elf_flags_init (obfd) = TRUE;
6576
      old_flags = new_flags;
6577
    }
6578
 
6579
  else if (new_flags == old_flags)              /* Compatible flags are ok.  */
6580
    ;
6581
 
6582
  else                                          /* Possibly incompatible flags.  */
6583
    {
6584
      /* Warn if different # of gprs are used.  Note, 0 means nothing is
6585
         said about the size of gprs.  */
6586
      new_partial = (new_flags & EF_FRV_GPR_MASK);
6587
      old_partial = (old_flags & EF_FRV_GPR_MASK);
6588
      if (new_partial == old_partial)
6589
        ;
6590
 
6591
      else if (new_partial == 0)
6592
        ;
6593
 
6594
      else if (old_partial == 0)
6595
        old_flags |= new_partial;
6596
 
6597
      else
6598
        {
6599
          switch (new_partial)
6600
            {
6601
            default:            strcat (new_opt, " -mgpr-??"); break;
6602
            case EF_FRV_GPR_32: strcat (new_opt, " -mgpr-32"); break;
6603
            case EF_FRV_GPR_64: strcat (new_opt, " -mgpr-64"); break;
6604
            }
6605
 
6606
          switch (old_partial)
6607
            {
6608
            default:            strcat (old_opt, " -mgpr-??"); break;
6609
            case EF_FRV_GPR_32: strcat (old_opt, " -mgpr-32"); break;
6610
            case EF_FRV_GPR_64: strcat (old_opt, " -mgpr-64"); break;
6611
            }
6612
        }
6613
 
6614
      /* Warn if different # of fprs are used.  Note, 0 means nothing is
6615
         said about the size of fprs.  */
6616
      new_partial = (new_flags & EF_FRV_FPR_MASK);
6617
      old_partial = (old_flags & EF_FRV_FPR_MASK);
6618
      if (new_partial == old_partial)
6619
        ;
6620
 
6621
      else if (new_partial == 0)
6622
        ;
6623
 
6624
      else if (old_partial == 0)
6625
        old_flags |= new_partial;
6626
 
6627
      else
6628
        {
6629
          switch (new_partial)
6630
            {
6631
            default:              strcat (new_opt, " -mfpr-?");      break;
6632
            case EF_FRV_FPR_32:   strcat (new_opt, " -mfpr-32");     break;
6633
            case EF_FRV_FPR_64:   strcat (new_opt, " -mfpr-64");     break;
6634
            case EF_FRV_FPR_NONE: strcat (new_opt, " -msoft-float"); break;
6635
            }
6636
 
6637
          switch (old_partial)
6638
            {
6639
            default:              strcat (old_opt, " -mfpr-?");      break;
6640
            case EF_FRV_FPR_32:   strcat (old_opt, " -mfpr-32");     break;
6641
            case EF_FRV_FPR_64:   strcat (old_opt, " -mfpr-64");     break;
6642
            case EF_FRV_FPR_NONE: strcat (old_opt, " -msoft-float"); break;
6643
            }
6644
        }
6645
 
6646
      /* Warn if different dword support was used.  Note, 0 means nothing is
6647
         said about the dword support.  */
6648
      new_partial = (new_flags & EF_FRV_DWORD_MASK);
6649
      old_partial = (old_flags & EF_FRV_DWORD_MASK);
6650
      if (new_partial == old_partial)
6651
        ;
6652
 
6653
      else if (new_partial == 0)
6654
        ;
6655
 
6656
      else if (old_partial == 0)
6657
        old_flags |= new_partial;
6658
 
6659
      else
6660
        {
6661
          switch (new_partial)
6662
            {
6663
            default:               strcat (new_opt, " -mdword-?");  break;
6664
            case EF_FRV_DWORD_YES: strcat (new_opt, " -mdword");    break;
6665
            case EF_FRV_DWORD_NO:  strcat (new_opt, " -mno-dword"); break;
6666
            }
6667
 
6668
          switch (old_partial)
6669
            {
6670
            default:               strcat (old_opt, " -mdword-?");  break;
6671
            case EF_FRV_DWORD_YES: strcat (old_opt, " -mdword");    break;
6672
            case EF_FRV_DWORD_NO:  strcat (old_opt, " -mno-dword"); break;
6673
            }
6674
        }
6675
 
6676
      /* Or in flags that accumulate (ie, if one module uses it, mark that the
6677
         feature is used.  */
6678
      old_flags |= new_flags & (EF_FRV_DOUBLE
6679
                                | EF_FRV_MEDIA
6680
                                | EF_FRV_MULADD
6681
                                | EF_FRV_NON_PIC_RELOCS);
6682
 
6683
      /* If any module was compiled without -G0, clear the G0 bit.  */
6684
      old_flags = ((old_flags & ~ EF_FRV_G0)
6685
                   | (old_flags & new_flags & EF_FRV_G0));
6686
 
6687
      /* If any module was compiled without -mnopack, clear the mnopack bit.  */
6688
      old_flags = ((old_flags & ~ EF_FRV_NOPACK)
6689
                   | (old_flags & new_flags & EF_FRV_NOPACK));
6690
 
6691
      /* We don't have to do anything if the pic flags are the same, or the new
6692
         module(s) were compiled with -mlibrary-pic.  */
6693
      new_partial = (new_flags & EF_FRV_PIC_FLAGS);
6694
      old_partial = (old_flags & EF_FRV_PIC_FLAGS);
6695
      if ((new_partial == old_partial) || ((new_partial & EF_FRV_LIBPIC) != 0))
6696
        ;
6697
 
6698
      /* If the old module(s) were compiled with -mlibrary-pic, copy in the pic
6699
         flags if any from the new module.  */
6700
      else if ((old_partial & EF_FRV_LIBPIC) != 0)
6701
        old_flags = (old_flags & ~ EF_FRV_PIC_FLAGS) | new_partial;
6702
 
6703
      /* If we have mixtures of -fpic and -fPIC, or in both bits.  */
6704
      else if (new_partial != 0 && old_partial != 0)
6705
        old_flags |= new_partial;
6706
 
6707
      /* One module was compiled for pic and the other was not, see if we have
6708
         had any relocations that are not pic-safe.  */
6709
      else
6710
        {
6711
          if ((old_flags & EF_FRV_NON_PIC_RELOCS) == 0)
6712
            old_flags |= new_partial;
6713
          else
6714
            {
6715
              old_flags &= ~ EF_FRV_PIC_FLAGS;
6716
#ifndef FRV_NO_PIC_ERROR
6717
              error = TRUE;
6718
              (*_bfd_error_handler)
6719
                (_("%s: compiled with %s and linked with modules that use non-pic relocations"),
6720
                 bfd_get_filename (ibfd),
6721
                 (new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
6722
#endif
6723
            }
6724
        }
6725
 
6726
      /* Warn if different cpu is used (allow a specific cpu to override
6727
         the generic cpu).  */
6728
      new_partial = (new_flags & EF_FRV_CPU_MASK);
6729
      old_partial = (old_flags & EF_FRV_CPU_MASK);
6730
      if (frv_elf_arch_extension_p (new_partial, old_partial))
6731
        ;
6732
 
6733
      else if (frv_elf_arch_extension_p (old_partial, new_partial))
6734
        old_flags = (old_flags & ~EF_FRV_CPU_MASK) | new_partial;
6735
 
6736
      else
6737
        {
6738
          switch (new_partial)
6739
            {
6740
            default:                 strcat (new_opt, " -mcpu=?");      break;
6741
            case EF_FRV_CPU_GENERIC: strcat (new_opt, " -mcpu=frv");    break;
6742
            case EF_FRV_CPU_SIMPLE:  strcat (new_opt, " -mcpu=simple"); break;
6743
            case EF_FRV_CPU_FR550:   strcat (new_opt, " -mcpu=fr550");  break;
6744
            case EF_FRV_CPU_FR500:   strcat (new_opt, " -mcpu=fr500");  break;
6745
            case EF_FRV_CPU_FR450:   strcat (new_opt, " -mcpu=fr450");  break;
6746
            case EF_FRV_CPU_FR405:   strcat (new_opt, " -mcpu=fr405");  break;
6747
            case EF_FRV_CPU_FR400:   strcat (new_opt, " -mcpu=fr400");  break;
6748
            case EF_FRV_CPU_FR300:   strcat (new_opt, " -mcpu=fr300");  break;
6749
            case EF_FRV_CPU_TOMCAT:  strcat (new_opt, " -mcpu=tomcat"); break;
6750
            }
6751
 
6752
          switch (old_partial)
6753
            {
6754
            default:                 strcat (old_opt, " -mcpu=?");      break;
6755
            case EF_FRV_CPU_GENERIC: strcat (old_opt, " -mcpu=frv");    break;
6756
            case EF_FRV_CPU_SIMPLE:  strcat (old_opt, " -mcpu=simple"); break;
6757
            case EF_FRV_CPU_FR550:   strcat (old_opt, " -mcpu=fr550");  break;
6758
            case EF_FRV_CPU_FR500:   strcat (old_opt, " -mcpu=fr500");  break;
6759
            case EF_FRV_CPU_FR450:   strcat (old_opt, " -mcpu=fr450");  break;
6760
            case EF_FRV_CPU_FR405:   strcat (old_opt, " -mcpu=fr405");  break;
6761
            case EF_FRV_CPU_FR400:   strcat (old_opt, " -mcpu=fr400");  break;
6762
            case EF_FRV_CPU_FR300:   strcat (old_opt, " -mcpu=fr300");  break;
6763
            case EF_FRV_CPU_TOMCAT:  strcat (old_opt, " -mcpu=tomcat"); break;
6764
            }
6765
        }
6766
 
6767
      /* Print out any mismatches from above.  */
6768
      if (new_opt[0])
6769
        {
6770
          error = TRUE;
6771
          (*_bfd_error_handler)
6772
            (_("%s: compiled with %s and linked with modules compiled with %s"),
6773
             bfd_get_filename (ibfd), new_opt, old_opt);
6774
        }
6775
 
6776
      /* Warn about any other mismatches */
6777
      new_partial = (new_flags & ~ EF_FRV_ALL_FLAGS);
6778
      old_partial = (old_flags & ~ EF_FRV_ALL_FLAGS);
6779
      if (new_partial != old_partial)
6780
        {
6781
          old_flags |= new_partial;
6782
          error = TRUE;
6783
          (*_bfd_error_handler)
6784
            (_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),
6785
             bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);
6786
        }
6787
    }
6788
 
6789
  /* If the cpu is -mcpu=simple, then set the -mnopack bit.  */
6790
  if ((old_flags & EF_FRV_CPU_MASK) == EF_FRV_CPU_SIMPLE)
6791
    old_flags |= EF_FRV_NOPACK;
6792
 
6793
  /* Update the old flags now with changes made above.  */
6794
  old_partial = elf_elfheader (obfd)->e_flags & EF_FRV_CPU_MASK;
6795
  elf_elfheader (obfd)->e_flags = old_flags;
6796
  if (old_partial != (old_flags & EF_FRV_CPU_MASK))
6797
    bfd_default_set_arch_mach (obfd, bfd_arch_frv, elf32_frv_machine (obfd));
6798
 
6799
  if (((new_flags & EF_FRV_FDPIC) == 0)
6800
      != (! IS_FDPIC (ibfd)))
6801
    {
6802
      error = TRUE;
6803
      if (IS_FDPIC (obfd))
6804
        (*_bfd_error_handler)
6805
          (_("%s: cannot link non-fdpic object file into fdpic executable"),
6806
           bfd_get_filename (ibfd));
6807
      else
6808
        (*_bfd_error_handler)
6809
          (_("%s: cannot link fdpic object file into non-fdpic executable"),
6810
           bfd_get_filename (ibfd));
6811
    }
6812
 
6813
  if (error)
6814
    bfd_set_error (bfd_error_bad_value);
6815
 
6816
  return !error;
6817
}
6818
 
6819
 
6820
bfd_boolean
6821
frv_elf_print_private_bfd_data (abfd, ptr)
6822
     bfd *abfd;
6823
     PTR ptr;
6824
{
6825
  FILE *file = (FILE *) ptr;
6826
  flagword flags;
6827
 
6828
  BFD_ASSERT (abfd != NULL && ptr != NULL);
6829
 
6830
  /* Print normal ELF private data.  */
6831
  _bfd_elf_print_private_bfd_data (abfd, ptr);
6832
 
6833
  flags = elf_elfheader (abfd)->e_flags;
6834
  fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
6835
 
6836
  switch (flags & EF_FRV_CPU_MASK)
6837
    {
6838
    default:                                                    break;
6839
    case EF_FRV_CPU_SIMPLE: fprintf (file, " -mcpu=simple");    break;
6840
    case EF_FRV_CPU_FR550:  fprintf (file, " -mcpu=fr550");     break;
6841
    case EF_FRV_CPU_FR500:  fprintf (file, " -mcpu=fr500");     break;
6842
    case EF_FRV_CPU_FR450:  fprintf (file, " -mcpu=fr450");     break;
6843
    case EF_FRV_CPU_FR405:  fprintf (file, " -mcpu=fr405");     break;
6844
    case EF_FRV_CPU_FR400:  fprintf (file, " -mcpu=fr400");     break;
6845
    case EF_FRV_CPU_FR300:  fprintf (file, " -mcpu=fr300");     break;
6846
    case EF_FRV_CPU_TOMCAT: fprintf (file, " -mcpu=tomcat");    break;
6847
    }
6848
 
6849
  switch (flags & EF_FRV_GPR_MASK)
6850
    {
6851
    default:                                                    break;
6852
    case EF_FRV_GPR_32: fprintf (file, " -mgpr-32");            break;
6853
    case EF_FRV_GPR_64: fprintf (file, " -mgpr-64");            break;
6854
    }
6855
 
6856
  switch (flags & EF_FRV_FPR_MASK)
6857
    {
6858
    default:                                                    break;
6859
    case EF_FRV_FPR_32:   fprintf (file, " -mfpr-32");          break;
6860
    case EF_FRV_FPR_64:   fprintf (file, " -mfpr-64");          break;
6861
    case EF_FRV_FPR_NONE: fprintf (file, " -msoft-float");      break;
6862
    }
6863
 
6864
  switch (flags & EF_FRV_DWORD_MASK)
6865
    {
6866
    default:                                                    break;
6867
    case EF_FRV_DWORD_YES: fprintf (file, " -mdword");          break;
6868
    case EF_FRV_DWORD_NO:  fprintf (file, " -mno-dword");       break;
6869
    }
6870
 
6871
  if (flags & EF_FRV_DOUBLE)
6872
    fprintf (file, " -mdouble");
6873
 
6874
  if (flags & EF_FRV_MEDIA)
6875
    fprintf (file, " -mmedia");
6876
 
6877
  if (flags & EF_FRV_MULADD)
6878
    fprintf (file, " -mmuladd");
6879
 
6880
  if (flags & EF_FRV_PIC)
6881
    fprintf (file, " -fpic");
6882
 
6883
  if (flags & EF_FRV_BIGPIC)
6884
    fprintf (file, " -fPIC");
6885
 
6886
  if (flags & EF_FRV_LIBPIC)
6887
    fprintf (file, " -mlibrary-pic");
6888
 
6889
  if (flags & EF_FRV_FDPIC)
6890
    fprintf (file, " -mfdpic");
6891
 
6892
  if (flags & EF_FRV_NON_PIC_RELOCS)
6893
    fprintf (file, " non-pic relocations");
6894
 
6895
  if (flags & EF_FRV_G0)
6896
    fprintf (file, " -G0");
6897
 
6898
  fputc ('\n', file);
6899
  return TRUE;
6900
}
6901
 
6902
 
6903
/* Support for core dump NOTE sections.  */
6904
 
6905
static bfd_boolean
6906
elf32_frv_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
6907
{
6908
  int offset;
6909
  unsigned int raw_size;
6910
 
6911
  switch (note->descsz)
6912
    {
6913
      default:
6914
        return FALSE;
6915
 
6916
      /* The Linux/FRV elf_prstatus struct is 268 bytes long.  The other
6917
         hardcoded offsets and sizes listed below (and contained within
6918
         this lexical block) refer to fields in the target's elf_prstatus
6919
         struct.  */
6920
      case 268:
6921
        /* `pr_cursig' is at offset 12.  */
6922
        elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
6923
 
6924
        /* `pr_pid' is at offset 24.  */
6925
        elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
6926
 
6927
        /* `pr_reg' is at offset 72.  */
6928
        offset = 72;
6929
 
6930
        /* Most grok_prstatus implementations set `raw_size' to the size
6931
           of the pr_reg field.  For Linux/FRV, we set `raw_size' to be
6932
           the size of `pr_reg' plus the size of `pr_exec_fdpic_loadmap'
6933
           and `pr_interp_fdpic_loadmap', both of which (by design)
6934
           immediately follow `pr_reg'.  This will allow these fields to
6935
           be viewed by GDB as registers.
6936
 
6937
           `pr_reg' is 184 bytes long.  `pr_exec_fdpic_loadmap' and
6938
           `pr_interp_fdpic_loadmap' are 4 bytes each.  */
6939
        raw_size = 184 + 4 + 4;
6940
 
6941
        break;
6942
    }
6943
 
6944
  /* Make a ".reg/999" section.  */
6945
  return _bfd_elfcore_make_pseudosection (abfd, ".reg", raw_size,
6946
                                          note->descpos + offset);
6947
}
6948
 
6949
static bfd_boolean
6950
elf32_frv_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
6951
{
6952
  switch (note->descsz)
6953
    {
6954
      default:
6955
        return FALSE;
6956
 
6957
      /* The Linux/FRV elf_prpsinfo struct is 124 bytes long.  */
6958
      case 124:
6959
 
6960
        /* `pr_fname' is found at offset 28 and is 16 bytes long.  */
6961
        elf_tdata (abfd)->core_program
6962
          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
6963
 
6964
        /* `pr_psargs' is found at offset 44 and is 80 bytes long.  */
6965
        elf_tdata (abfd)->core_command
6966
          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
6967
    }
6968
 
6969
  /* Note that for some reason, a spurious space is tacked
6970
     onto the end of the args in some (at least one anyway)
6971
     implementations, so strip it off if it exists.  */
6972
 
6973
  {
6974
    char *command = elf_tdata (abfd)->core_command;
6975
    int n = strlen (command);
6976
 
6977
    if (0 < n && command[n - 1] == ' ')
6978
      command[n - 1] = '\0';
6979
  }
6980
 
6981
  return TRUE;
6982
}
6983
#define ELF_ARCH                bfd_arch_frv
6984
#define ELF_TARGET_ID           FRV_ELF_DATA
6985
#define ELF_MACHINE_CODE        EM_CYGNUS_FRV
6986
#define ELF_MAXPAGESIZE         0x1000
6987
 
6988
#define TARGET_BIG_SYM          bfd_elf32_frv_vec
6989
#define TARGET_BIG_NAME         "elf32-frv"
6990
 
6991
#define elf_info_to_howto                       frv_info_to_howto_rela
6992
#define elf_backend_relocate_section            elf32_frv_relocate_section
6993
#define elf_backend_gc_mark_hook                elf32_frv_gc_mark_hook
6994
#define elf_backend_check_relocs                elf32_frv_check_relocs
6995
#define elf_backend_object_p                    elf32_frv_object_p
6996
#define elf_backend_add_symbol_hook             elf32_frv_add_symbol_hook
6997
 
6998
#define elf_backend_can_gc_sections             1
6999
#define elf_backend_rela_normal                 1
7000
 
7001
#define bfd_elf32_bfd_reloc_type_lookup         frv_reloc_type_lookup
7002
#define bfd_elf32_bfd_reloc_name_lookup frv_reloc_name_lookup
7003
#define bfd_elf32_bfd_set_private_flags         frv_elf_set_private_flags
7004
#define bfd_elf32_bfd_copy_private_bfd_data     frv_elf_copy_private_bfd_data
7005
#define bfd_elf32_bfd_merge_private_bfd_data    frv_elf_merge_private_bfd_data
7006
#define bfd_elf32_bfd_print_private_bfd_data    frv_elf_print_private_bfd_data
7007
 
7008
#define elf_backend_want_got_sym        1
7009
#define elf_backend_got_header_size     0
7010
#define elf_backend_want_got_plt        0
7011
#define elf_backend_plt_readonly        1
7012
#define elf_backend_want_plt_sym        0
7013
#define elf_backend_plt_header_size     0
7014
 
7015
#define elf_backend_finish_dynamic_sections \
7016
                elf32_frv_finish_dynamic_sections
7017
 
7018
#define elf_backend_grok_prstatus       elf32_frv_grok_prstatus
7019
#define elf_backend_grok_psinfo         elf32_frv_grok_psinfo
7020
 
7021
#include "elf32-target.h"
7022
 
7023
#undef ELF_MAXPAGESIZE
7024
#define ELF_MAXPAGESIZE         0x4000
7025
 
7026
#undef TARGET_BIG_SYM
7027
#define TARGET_BIG_SYM          bfd_elf32_frvfdpic_vec
7028
#undef TARGET_BIG_NAME
7029
#define TARGET_BIG_NAME         "elf32-frvfdpic"
7030
#undef  elf32_bed
7031
#define elf32_bed               elf32_frvfdpic_bed
7032
 
7033
#undef elf_info_to_howto_rel
7034
#define elf_info_to_howto_rel   frvfdpic_info_to_howto_rel
7035
 
7036
#undef bfd_elf32_bfd_link_hash_table_create
7037
#define bfd_elf32_bfd_link_hash_table_create \
7038
                frvfdpic_elf_link_hash_table_create
7039
#undef elf_backend_always_size_sections
7040
#define elf_backend_always_size_sections \
7041
                elf32_frvfdpic_always_size_sections
7042
#undef elf_backend_modify_program_headers
7043
#define elf_backend_modify_program_headers \
7044
                elf32_frvfdpic_modify_program_headers
7045
#undef bfd_elf32_bfd_copy_private_bfd_data
7046
#define bfd_elf32_bfd_copy_private_bfd_data \
7047
                elf32_frvfdpic_copy_private_bfd_data
7048
 
7049
#undef elf_backend_create_dynamic_sections
7050
#define elf_backend_create_dynamic_sections \
7051
                elf32_frvfdpic_create_dynamic_sections
7052
#undef elf_backend_adjust_dynamic_symbol
7053
#define elf_backend_adjust_dynamic_symbol \
7054
                elf32_frvfdpic_adjust_dynamic_symbol
7055
#undef elf_backend_size_dynamic_sections
7056
#define elf_backend_size_dynamic_sections \
7057
                elf32_frvfdpic_size_dynamic_sections
7058
#undef bfd_elf32_bfd_relax_section
7059
#define bfd_elf32_bfd_relax_section \
7060
  elf32_frvfdpic_relax_section
7061
#undef elf_backend_finish_dynamic_symbol
7062
#define elf_backend_finish_dynamic_symbol \
7063
                elf32_frvfdpic_finish_dynamic_symbol
7064
#undef elf_backend_finish_dynamic_sections
7065
#define elf_backend_finish_dynamic_sections \
7066
                elf32_frvfdpic_finish_dynamic_sections
7067
 
7068
#undef elf_backend_discard_info
7069
#define elf_backend_discard_info \
7070
                frvfdpic_elf_discard_info
7071
#undef elf_backend_can_make_relative_eh_frame
7072
#define elf_backend_can_make_relative_eh_frame \
7073
                frvfdpic_elf_use_relative_eh_frame
7074
#undef elf_backend_can_make_lsda_relative_eh_frame
7075
#define elf_backend_can_make_lsda_relative_eh_frame \
7076
                frvfdpic_elf_use_relative_eh_frame
7077
#undef elf_backend_encode_eh_address
7078
#define elf_backend_encode_eh_address \
7079
                frvfdpic_elf_encode_eh_address
7080
 
7081
#undef elf_backend_may_use_rel_p
7082
#define elf_backend_may_use_rel_p       1
7083
#undef elf_backend_may_use_rela_p
7084
#define elf_backend_may_use_rela_p      1
7085
/* We use REL for dynamic relocations only.  */
7086
#undef elf_backend_default_use_rela_p
7087
#define elf_backend_default_use_rela_p  1
7088
 
7089
#undef elf_backend_omit_section_dynsym
7090
#define elf_backend_omit_section_dynsym _frvfdpic_link_omit_section_dynsym
7091
 
7092
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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