Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/bfd/elf32-bfin.c
Line
Count
Source (jump to first uncovered line)
1
/* ADI Blackfin BFD support for 32-bit ELF.
2
   Copyright (C) 2005-2024 Free Software Foundation, Inc.
3
4
   This file is part of BFD, the Binary File Descriptor library.
5
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 3 of the License, or
9
   (at your option) any later version.
10
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19
   MA 02110-1301, USA.  */
20
21
#include "sysdep.h"
22
#include "bfd.h"
23
#include "libbfd.h"
24
#include "elf-bfd.h"
25
#include "elf/bfin.h"
26
#include "dwarf2.h"
27
#include "hashtab.h"
28
#include "elf32-bfin.h"
29
30
/* FUNCTION : bfin_pltpc_reloc
31
   ABSTRACT : TODO : figure out how to handle pltpc relocs.  */
32
static bfd_reloc_status_type
33
bfin_pltpc_reloc (
34
     bfd *abfd ATTRIBUTE_UNUSED,
35
     arelent *reloc_entry ATTRIBUTE_UNUSED,
36
     asymbol *symbol ATTRIBUTE_UNUSED,
37
     void * data ATTRIBUTE_UNUSED,
38
     asection *input_section ATTRIBUTE_UNUSED,
39
     bfd *output_bfd ATTRIBUTE_UNUSED,
40
     char **error_message ATTRIBUTE_UNUSED)
41
0
{
42
0
  bfd_reloc_status_type flag = bfd_reloc_ok;
43
0
  return flag;
44
0
}
45

46
47
static bfd_reloc_status_type
48
bfin_pcrel24_reloc (bfd *abfd,
49
        arelent *reloc_entry,
50
        asymbol *symbol,
51
        void * data,
52
        asection *input_section,
53
        bfd *output_bfd,
54
        char **error_message ATTRIBUTE_UNUSED)
55
0
{
56
0
  bfd_vma relocation;
57
0
  bfd_size_type addr = reloc_entry->address;
58
0
  bfd_vma output_base = 0;
59
0
  reloc_howto_type *howto = reloc_entry->howto;
60
0
  asection *output_section;
61
0
  bool relocatable = (output_bfd != NULL);
62
63
0
  if (!bfd_reloc_offset_in_range (howto, abfd, input_section, addr - 2))
64
0
    return bfd_reloc_outofrange;
65
66
0
  if (bfd_is_und_section (symbol->section)
67
0
      && (symbol->flags & BSF_WEAK) == 0
68
0
      && !relocatable)
69
0
    return bfd_reloc_undefined;
70
71
0
  if (bfd_is_com_section (symbol->section))
72
0
    relocation = 0;
73
0
  else
74
0
    relocation = symbol->value;
75
76
0
  output_section = symbol->section->output_section;
77
78
0
  if (relocatable)
79
0
    output_base = 0;
80
0
  else
81
0
    output_base = output_section->vma;
82
83
0
  if (!relocatable || !strcmp (symbol->name, symbol->section->name))
84
0
    relocation += output_base + symbol->section->output_offset;
85
86
0
  if (!relocatable && !strcmp (symbol->name, symbol->section->name))
87
0
    relocation += reloc_entry->addend;
88
89
0
  relocation -= input_section->output_section->vma + input_section->output_offset;
90
0
  relocation -= reloc_entry->address;
91
92
0
  if (howto->complain_on_overflow != complain_overflow_dont)
93
0
    {
94
0
      bfd_reloc_status_type status;
95
0
      status = bfd_check_overflow (howto->complain_on_overflow,
96
0
           howto->bitsize,
97
0
           howto->rightshift,
98
0
           bfd_arch_bits_per_address(abfd),
99
0
           relocation);
100
0
      if (status != bfd_reloc_ok)
101
0
  return status;
102
0
    }
103
104
  /* if rightshift is 1 and the number odd, return error.  */
105
0
  if (howto->rightshift && (relocation & 0x01))
106
0
    {
107
0
      _bfd_error_handler (_("relocation should be even number"));
108
0
      return bfd_reloc_overflow;
109
0
    }
110
111
0
  relocation >>= (bfd_vma) howto->rightshift;
112
  /* Shift everything up to where it's going to be used.  */
113
114
0
  relocation <<= (bfd_vma) howto->bitpos;
115
116
0
  if (relocatable)
117
0
    {
118
0
      reloc_entry->address += input_section->output_offset;
119
0
      reloc_entry->addend += symbol->section->output_offset;
120
0
    }
121
122
0
  {
123
0
    short x;
124
125
    /* We are getting reloc_entry->address 2 byte off from
126
       the start of instruction. Assuming absolute postion
127
       of the reloc data. But, following code had been written assuming
128
       reloc address is starting at begining of instruction.
129
       To compensate that I have increased the value of
130
       relocation by 1 (effectively 2) and used the addr -2 instead of addr.  */
131
132
0
    relocation += 1;
133
0
    x = bfd_get_16 (abfd, (bfd_byte *) data + addr - 2);
134
0
    x = (x & 0xff00) | ((relocation >> 16) & 0xff);
135
0
    bfd_put_16 (abfd, x, (unsigned char *) data + addr - 2);
136
137
0
    x = bfd_get_16 (abfd, (bfd_byte *) data + addr);
138
0
    x = relocation & 0xFFFF;
139
0
    bfd_put_16 (abfd, x, (unsigned char *) data + addr );
140
0
  }
141
0
  return bfd_reloc_ok;
142
0
}
143
144
static bfd_reloc_status_type
145
bfin_imm16_reloc (bfd *abfd,
146
      arelent *reloc_entry,
147
      asymbol *symbol,
148
      void * data,
149
      asection *input_section,
150
      bfd *output_bfd,
151
      char **error_message ATTRIBUTE_UNUSED)
152
0
{
153
0
  bfd_vma relocation, x;
154
0
  bfd_size_type reloc_addr = reloc_entry->address;
155
0
  bfd_vma output_base = 0;
156
0
  reloc_howto_type *howto = reloc_entry->howto;
157
0
  asection *output_section;
158
0
  bool relocatable = (output_bfd != NULL);
159
160
  /* Is the address of the relocation really within the section?  */
161
0
  if (!bfd_reloc_offset_in_range (howto, abfd, input_section, reloc_addr))
162
0
    return bfd_reloc_outofrange;
163
164
0
  if (bfd_is_und_section (symbol->section)
165
0
      && (symbol->flags & BSF_WEAK) == 0
166
0
      && !relocatable)
167
0
    return bfd_reloc_undefined;
168
169
0
  output_section = symbol->section->output_section;
170
0
  relocation = symbol->value;
171
172
  /* Convert input-section-relative symbol value to absolute.  */
173
0
  if (relocatable)
174
0
    output_base = 0;
175
0
  else
176
0
    output_base = output_section->vma;
177
178
0
  if (!relocatable || !strcmp (symbol->name, symbol->section->name))
179
0
    relocation += output_base + symbol->section->output_offset;
180
181
  /* Add in supplied addend.  */
182
0
  relocation += reloc_entry->addend;
183
184
0
  if (relocatable)
185
0
    {
186
0
      reloc_entry->address += input_section->output_offset;
187
0
      reloc_entry->addend += symbol->section->output_offset;
188
0
    }
189
0
  else
190
0
    {
191
0
      reloc_entry->addend = 0;
192
0
    }
193
194
0
  if (howto->complain_on_overflow != complain_overflow_dont)
195
0
    {
196
0
      bfd_reloc_status_type flag;
197
0
      flag = bfd_check_overflow (howto->complain_on_overflow,
198
0
         howto->bitsize,
199
0
         howto->rightshift,
200
0
         bfd_arch_bits_per_address(abfd),
201
0
         relocation);
202
0
      if (flag != bfd_reloc_ok)
203
0
  return flag;
204
0
    }
205
206
  /* Here the variable relocation holds the final address of the
207
     symbol we are relocating against, plus any addend.  */
208
209
0
  relocation >>= (bfd_vma) howto->rightshift;
210
0
  x = relocation;
211
0
  bfd_put_16 (abfd, x, (unsigned char *) data + reloc_addr);
212
0
  return bfd_reloc_ok;
213
0
}
214
215
216
static bfd_reloc_status_type
217
bfin_byte4_reloc (bfd *abfd,
218
      arelent *reloc_entry,
219
      asymbol *symbol,
220
      void * data,
221
      asection *input_section,
222
      bfd *output_bfd,
223
      char **error_message ATTRIBUTE_UNUSED)
224
0
{
225
0
  bfd_vma relocation, x;
226
0
  bfd_size_type addr = reloc_entry->address;
227
0
  bfd_vma output_base = 0;
228
0
  asection *output_section;
229
0
  bool relocatable = (output_bfd != NULL);
230
231
  /* Is the address of the relocation really within the section?  */
232
0
  if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd, input_section,
233
0
          addr))
234
0
    return bfd_reloc_outofrange;
235
236
0
  if (bfd_is_und_section (symbol->section)
237
0
      && (symbol->flags & BSF_WEAK) == 0
238
0
      && !relocatable)
239
0
    return bfd_reloc_undefined;
240
241
0
  output_section = symbol->section->output_section;
242
0
  relocation = symbol->value;
243
  /* Convert input-section-relative symbol value to absolute.  */
244
0
  if (relocatable)
245
0
    output_base = 0;
246
0
  else
247
0
    output_base = output_section->vma;
248
249
0
  if ((symbol->name
250
0
       && symbol->section->name
251
0
       && !strcmp (symbol->name, symbol->section->name))
252
0
      || !relocatable)
253
0
    {
254
0
      relocation += output_base + symbol->section->output_offset;
255
0
    }
256
257
0
  relocation += reloc_entry->addend;
258
259
0
  if (relocatable)
260
0
    {
261
      /* This output will be relocatable ... like ld -r. */
262
0
      reloc_entry->address += input_section->output_offset;
263
0
      reloc_entry->addend += symbol->section->output_offset;
264
0
    }
265
0
  else
266
0
    {
267
0
      reloc_entry->addend = 0;
268
0
    }
269
270
  /* Here the variable relocation holds the final address of the
271
     symbol we are relocating against, plus any addend.  */
272
0
  x = relocation & 0xFFFF0000;
273
0
  x >>=16;
274
0
  bfd_put_16 (abfd, x, (unsigned char *) data + addr + 2);
275
276
0
  x = relocation & 0x0000FFFF;
277
0
  bfd_put_16 (abfd, x, (unsigned char *) data + addr);
278
0
  return bfd_reloc_ok;
279
0
}
280
281
/* bfin_bfd_reloc handles the blackfin arithmetic relocations.
282
   Use this instead of bfd_perform_relocation.  */
283
static bfd_reloc_status_type
284
bfin_bfd_reloc (bfd *abfd,
285
    arelent *reloc_entry,
286
    asymbol *symbol,
287
    void * data,
288
    asection *input_section,
289
    bfd *output_bfd,
290
    char **error_message ATTRIBUTE_UNUSED)
291
0
{
292
0
  bfd_vma relocation;
293
0
  bfd_size_type addr = reloc_entry->address;
294
0
  bfd_vma output_base = 0;
295
0
  reloc_howto_type *howto = reloc_entry->howto;
296
0
  asection *output_section;
297
0
  bool relocatable = (output_bfd != NULL);
298
299
  /* Is the address of the relocation really within the section?  */
300
0
  if (!bfd_reloc_offset_in_range (howto, abfd, input_section, addr))
301
0
    return bfd_reloc_outofrange;
302
303
0
  if (bfd_is_und_section (symbol->section)
304
0
      && (symbol->flags & BSF_WEAK) == 0
305
0
      && !relocatable)
306
0
    return bfd_reloc_undefined;
307
308
  /* Get symbol value.  (Common symbols are special.)  */
309
0
  if (bfd_is_com_section (symbol->section))
310
0
    relocation = 0;
311
0
  else
312
0
    relocation = symbol->value;
313
314
0
  output_section = symbol->section->output_section;
315
316
  /* Convert input-section-relative symbol value to absolute.  */
317
0
  if (relocatable)
318
0
    output_base = 0;
319
0
  else
320
0
    output_base = output_section->vma;
321
322
0
  if (!relocatable || !strcmp (symbol->name, symbol->section->name))
323
0
    relocation += output_base + symbol->section->output_offset;
324
325
0
  if (!relocatable && !strcmp (symbol->name, symbol->section->name))
326
0
    {
327
      /* Add in supplied addend.  */
328
0
      relocation += reloc_entry->addend;
329
0
    }
330
331
  /* Here the variable relocation holds the final address of the
332
     symbol we are relocating against, plus any addend.  */
333
334
0
  if (howto->pc_relative)
335
0
    {
336
0
      relocation -= input_section->output_section->vma + input_section->output_offset;
337
338
0
      if (howto->pcrel_offset)
339
0
  relocation -= reloc_entry->address;
340
0
    }
341
342
0
  if (relocatable)
343
0
    {
344
0
      reloc_entry->address += input_section->output_offset;
345
0
      reloc_entry->addend += symbol->section->output_offset;
346
0
    }
347
348
0
  if (howto->complain_on_overflow != complain_overflow_dont)
349
0
    {
350
0
      bfd_reloc_status_type status;
351
352
0
      status = bfd_check_overflow (howto->complain_on_overflow,
353
0
          howto->bitsize,
354
0
          howto->rightshift,
355
0
          bfd_arch_bits_per_address(abfd),
356
0
          relocation);
357
0
      if (status != bfd_reloc_ok)
358
0
  return status;
359
0
    }
360
361
  /* If rightshift is 1 and the number odd, return error.  */
362
0
  if (howto->rightshift && (relocation & 0x01))
363
0
    {
364
0
      _bfd_error_handler (_("relocation should be even number"));
365
0
      return bfd_reloc_overflow;
366
0
    }
367
368
0
  relocation >>= (bfd_vma) howto->rightshift;
369
370
  /* Shift everything up to where it's going to be used.  */
371
372
0
  relocation <<= (bfd_vma) howto->bitpos;
373
374
0
#define DOIT(x)               \
375
0
  x = ( (x & ~howto->dst_mask) | (relocation & howto->dst_mask))
376
377
  /* handle 8 and 16 bit relocations here. */
378
0
  switch (bfd_get_reloc_size (howto))
379
0
    {
380
0
    case 1:
381
0
      {
382
0
  char x = bfd_get_8 (abfd, (char *) data + addr);
383
0
  DOIT (x);
384
0
  bfd_put_8 (abfd, x, (unsigned char *) data + addr);
385
0
      }
386
0
      break;
387
388
0
    case 2:
389
0
      {
390
0
  unsigned short x = bfd_get_16 (abfd, (bfd_byte *) data + addr);
391
0
  DOIT (x);
392
0
  bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + addr);
393
0
      }
394
0
      break;
395
396
0
    default:
397
0
      return bfd_reloc_other;
398
0
    }
399
400
0
  return bfd_reloc_ok;
401
0
}
402
403
/* HOWTO Table for blackfin.
404
   Blackfin relocations are fairly complicated.
405
   Some of the salient features are
406
   a. Even numbered offsets. A number of (not all) relocations are
407
      even numbered. This means that the rightmost bit is not stored.
408
      Needs to right shift by 1 and check to see if value is not odd
409
   b. A relocation can be an expression. An expression takes on
410
      a variety of relocations arranged in a stack.
411
   As a result, we cannot use the standard generic function as special
412
   function. We will have our own, which is very similar to the standard
413
   generic function except that it understands how to get the value from
414
   the relocation stack. .  */
415
416
#define BFIN_RELOC_MIN 0
417
0
#define BFIN_RELOC_MAX 0x21
418
0
#define BFIN_GNUEXT_RELOC_MIN 0x40
419
0
#define BFIN_GNUEXT_RELOC_MAX 0x43
420
#define BFIN_ARELOC_MIN 0xE0
421
#define BFIN_ARELOC_MAX 0xF3
422
423
static reloc_howto_type bfin_howto_table [] =
424
{
425
  /* This reloc does nothing. .  */
426
  HOWTO (R_BFIN_UNUSED0,  /* type.  */
427
   0,     /* rightshift.  */
428
   0,     /* size.  */
429
   0,     /* bitsize.  */
430
   false,     /* pc_relative.  */
431
   0,     /* bitpos.  */
432
   complain_overflow_dont, /* complain_on_overflow.  */
433
   bfd_elf_generic_reloc, /* special_function.  */
434
   "R_BFIN_UNUSED0",  /* name.  */
435
   false,     /* partial_inplace.  */
436
   0,     /* src_mask.  */
437
   0,     /* dst_mask.  */
438
   false),    /* pcrel_offset.  */
439
440
  HOWTO (R_BFIN_PCREL5M2, /* type.  */
441
   1,     /* rightshift.  */
442
   2,     /* size.  */
443
   4,     /* bitsize.  */
444
   true,      /* pc_relative.  */
445
   0,     /* bitpos.  */
446
   complain_overflow_unsigned, /* complain_on_overflow.  */
447
   bfin_bfd_reloc,  /* special_function.  */
448
   "R_BFIN_PCREL5M2", /* name.  */
449
   false,     /* partial_inplace.  */
450
   0,     /* src_mask.  */
451
   0x0000000F,    /* dst_mask.  */
452
   false),    /* pcrel_offset.  */
453
454
  HOWTO (R_BFIN_UNUSED1,  /* type.  */
455
   0,     /* rightshift.  */
456
   0,     /* size.  */
457
   0,     /* bitsize.  */
458
   false,     /* pc_relative.  */
459
   0,     /* bitpos.  */
460
   complain_overflow_dont, /* complain_on_overflow.  */
461
   bfd_elf_generic_reloc, /* special_function.  */
462
   "R_BFIN_UNUSED1",  /* name.  */
463
   false,     /* partial_inplace.  */
464
   0,     /* src_mask.  */
465
   0,     /* dst_mask.  */
466
   false),    /* pcrel_offset.  */
467
468
  HOWTO (R_BFIN_PCREL10,  /* type.  */
469
   1,     /* rightshift.  */
470
   2,     /* size.  */
471
   10,      /* bitsize.  */
472
   true,      /* pc_relative.  */
473
   0,     /* bitpos.  */
474
   complain_overflow_signed, /* complain_on_overflow.  */
475
   bfin_bfd_reloc,  /* special_function.  */
476
   "R_BFIN_PCREL10",  /* name.  */
477
   false,     /* partial_inplace.  */
478
   0,     /* src_mask.  */
479
   0x000003FF,    /* dst_mask.  */
480
   true),     /* pcrel_offset.  */
481
482
  HOWTO (R_BFIN_PCREL12_JUMP, /* type.  */
483
   1,     /* rightshift.  */
484
        /* the offset is actually 13 bit
485
           aligned on a word boundary so
486
           only 12 bits have to be used.
487
           Right shift the rightmost bit..  */
488
   2,     /* size.  */
489
   12,      /* bitsize.  */
490
   true,      /* pc_relative.  */
491
   0,     /* bitpos.  */
492
   complain_overflow_signed, /* complain_on_overflow.  */
493
   bfin_bfd_reloc,  /* special_function.  */
494
   "R_BFIN_PCREL12_JUMP", /* name.  */
495
   false,     /* partial_inplace.  */
496
   0,     /* src_mask.  */
497
   0x0FFF,    /* dst_mask.  */
498
   true),     /* pcrel_offset.  */
499
500
  HOWTO (R_BFIN_RIMM16,   /* type.  */
501
   0,     /* rightshift.  */
502
   2,     /* size.  */
503
   16,      /* bitsize.  */
504
   false,     /* pc_relative.  */
505
   0,     /* bitpos.  */
506
   complain_overflow_signed, /* complain_on_overflow.  */
507
   bfin_imm16_reloc,  /* special_function.  */
508
   "R_BFIN_RIMM16", /* name.  */
509
   false,     /* partial_inplace.  */
510
   0,     /* src_mask.  */
511
   0x0000FFFF,    /* dst_mask.  */
512
   true),     /* pcrel_offset.  */
513
514
  HOWTO (R_BFIN_LUIMM16,  /* type.  */
515
   0,     /* rightshift.  */
516
   2,     /* size.  */
517
   16,      /* bitsize.  */
518
   false,     /* pc_relative.  */
519
   0,     /* bitpos.  */
520
   complain_overflow_dont, /* complain_on_overflow.  */
521
   bfin_imm16_reloc,  /* special_function.  */
522
   "R_BFIN_LUIMM16",  /* name.  */
523
   false,     /* partial_inplace.  */
524
   0,     /* src_mask.  */
525
   0x0000FFFF,    /* dst_mask.  */
526
   true),     /* pcrel_offset.  */
527
528
  HOWTO (R_BFIN_HUIMM16,  /* type.  */
529
   16,      /* rightshift.  */
530
   2,     /* size.  */
531
   16,      /* bitsize.  */
532
   false,     /* pc_relative.  */
533
   0,     /* bitpos.  */
534
   complain_overflow_unsigned, /* complain_on_overflow.  */
535
   bfin_imm16_reloc,  /* special_function.  */
536
   "R_BFIN_HUIMM16",  /* name.  */
537
   false,     /* partial_inplace.  */
538
   0,     /* src_mask.  */
539
   0x0000FFFF,    /* dst_mask.  */
540
   true),     /* pcrel_offset.  */
541
542
  HOWTO (R_BFIN_PCREL12_JUMP_S, /* type.  */
543
   1,     /* rightshift.  */
544
   2,     /* size.  */
545
   12,      /* bitsize.  */
546
   true,      /* pc_relative.  */
547
   0,     /* bitpos.  */
548
   complain_overflow_signed, /* complain_on_overflow.  */
549
   bfin_bfd_reloc,  /* special_function.  */
550
   "R_BFIN_PCREL12_JUMP_S", /* name.  */
551
   false,     /* partial_inplace.  */
552
   0,     /* src_mask.  */
553
   0x00000FFF,    /* dst_mask.  */
554
   true),     /* pcrel_offset.  */
555
556
  HOWTO (R_BFIN_PCREL24_JUMP_X, /* type.  */
557
   1,     /* rightshift.  */
558
   4,     /* size.  */
559
   24,      /* bitsize.  */
560
   true,      /* pc_relative.  */
561
   0,     /* bitpos.  */
562
   complain_overflow_signed, /* complain_on_overflow.  */
563
   bfin_pcrel24_reloc,  /* special_function.  */
564
  "R_BFIN_PCREL24_JUMP_X", /* name.  */
565
   false,     /* partial_inplace.  */
566
   0,     /* src_mask.  */
567
   0x00FFFFFF,    /* dst_mask.  */
568
   true),     /* pcrel_offset.  */
569
570
  HOWTO (R_BFIN_PCREL24,  /* type.  */
571
   1,     /* rightshift.  */
572
   4,     /* size.  */
573
   24,      /* bitsize.  */
574
   true,      /* pc_relative.  */
575
   0,     /* bitpos.  */
576
   complain_overflow_signed, /* complain_on_overflow.  */
577
   bfin_pcrel24_reloc,  /* special_function.  */
578
   "R_BFIN_PCREL24",  /* name.  */
579
   false,     /* partial_inplace.  */
580
   0,     /* src_mask.  */
581
   0x00FFFFFF,    /* dst_mask.  */
582
   true),     /* pcrel_offset.  */
583
584
  HOWTO (R_BFIN_UNUSEDB,  /* type.  */
585
   0,     /* rightshift.  */
586
   0,     /* size.  */
587
   0,     /* bitsize.  */
588
   false,     /* pc_relative.  */
589
   0,     /* bitpos.  */
590
   complain_overflow_dont, /* complain_on_overflow.  */
591
   bfd_elf_generic_reloc, /* special_function.  */
592
   "R_BFIN_UNUSEDB",  /* name.  */
593
   false,     /* partial_inplace.  */
594
   0,     /* src_mask.  */
595
   0,     /* dst_mask.  */
596
   false),    /* pcrel_offset.  */
597
598
  HOWTO (R_BFIN_UNUSEDC,  /* type.  */
599
   0,     /* rightshift.  */
600
   0,     /* size.  */
601
   0,     /* bitsize.  */
602
   false,     /* pc_relative.  */
603
   0,     /* bitpos.  */
604
   complain_overflow_dont, /* complain_on_overflow.  */
605
   bfd_elf_generic_reloc, /* special_function.  */
606
   "R_BFIN_UNUSEDC",  /* name.  */
607
   false,     /* partial_inplace.  */
608
   0,     /* src_mask.  */
609
   0,     /* dst_mask.  */
610
   false),    /* pcrel_offset.  */
611
612
  HOWTO (R_BFIN_PCREL24_JUMP_L, /* type.  */
613
   1,     /* rightshift.  */
614
   4,     /* size.  */
615
   24,      /* bitsize.  */
616
   true,      /* pc_relative.  */
617
   0,     /* bitpos.  */
618
   complain_overflow_signed, /* complain_on_overflow.  */
619
   bfin_pcrel24_reloc,  /* special_function.  */
620
   "R_BFIN_PCREL24_JUMP_L", /* name.  */
621
   false,     /* partial_inplace.  */
622
   0,     /* src_mask.  */
623
   0x00FFFFFF,    /* dst_mask.  */
624
   true),     /* pcrel_offset.  */
625
626
  HOWTO (R_BFIN_PCREL24_CALL_X, /* type.  */
627
   1,     /* rightshift.  */
628
   4,     /* size.  */
629
   24,      /* bitsize.  */
630
   true,      /* pc_relative.  */
631
   0,     /* bitpos.  */
632
   complain_overflow_signed, /* complain_on_overflow.  */
633
   bfin_pcrel24_reloc,  /* special_function.  */
634
   "R_BFIN_PCREL24_CALL_X", /* name.  */
635
   false,     /* partial_inplace.  */
636
   0,     /* src_mask.  */
637
   0x00FFFFFF,    /* dst_mask.  */
638
   true),     /* pcrel_offset.  */
639
640
  HOWTO (R_BFIN_VAR_EQ_SYMB,  /* type.  */
641
   0,     /* rightshift.  */
642
   4,     /* size.  */
643
   32,      /* bitsize.  */
644
   false,     /* pc_relative.  */
645
   0,     /* bitpos.  */
646
   complain_overflow_bitfield, /* complain_on_overflow.  */
647
   bfin_bfd_reloc,  /* special_function.  */
648
   "R_BFIN_VAR_EQ_SYMB",  /* name.  */
649
   false,     /* partial_inplace.  */
650
   0,     /* src_mask.  */
651
   0,     /* dst_mask.  */
652
   false),    /* pcrel_offset.  */
653
654
  HOWTO (R_BFIN_BYTE_DATA,  /* type.  */
655
   0,     /* rightshift.  */
656
   1,     /* size.  */
657
   8,     /* bitsize.  */
658
   false,     /* pc_relative.  */
659
   0,     /* bitpos.  */
660
   complain_overflow_unsigned, /* complain_on_overflow.  */
661
   bfin_bfd_reloc,  /* special_function.  */
662
   "R_BFIN_BYTE_DATA",  /* name.  */
663
   false,     /* partial_inplace.  */
664
   0,     /* src_mask.  */
665
   0xFF,      /* dst_mask.  */
666
   true),     /* pcrel_offset.  */
667
668
  HOWTO (R_BFIN_BYTE2_DATA, /* type.  */
669
   0,     /* rightshift.  */
670
   2,     /* size.  */
671
   16,      /* bitsize.  */
672
   false,     /* pc_relative.  */
673
   0,     /* bitpos.  */
674
   complain_overflow_signed, /* complain_on_overflow.  */
675
   bfin_bfd_reloc,  /* special_function.  */
676
   "R_BFIN_BYTE2_DATA", /* name.  */
677
   false,     /* partial_inplace.  */
678
   0,     /* src_mask.  */
679
   0xFFFF,    /* dst_mask.  */
680
   true),     /* pcrel_offset.  */
681
682
  HOWTO (R_BFIN_BYTE4_DATA, /* type.  */
683
   0,     /* rightshift.  */
684
   4,     /* size.  */
685
   32,      /* bitsize.  */
686
   false,     /* pc_relative.  */
687
   0,     /* bitpos.  */
688
   complain_overflow_unsigned, /* complain_on_overflow.  */
689
   bfin_byte4_reloc,  /* special_function.  */
690
   "R_BFIN_BYTE4_DATA", /* name.  */
691
   false,     /* partial_inplace.  */
692
   0,     /* src_mask.  */
693
   0xFFFFFFFF,    /* dst_mask.  */
694
   true),     /* pcrel_offset.  */
695
696
  HOWTO (R_BFIN_PCREL11,  /* type.  */
697
   1,     /* rightshift.  */
698
   2,     /* size.  */
699
   10,      /* bitsize.  */
700
   true,      /* pc_relative.  */
701
   0,     /* bitpos.  */
702
   complain_overflow_unsigned, /* complain_on_overflow.  */
703
   bfin_bfd_reloc,  /* special_function.  */
704
   "R_BFIN_PCREL11",  /* name.  */
705
   false,     /* partial_inplace.  */
706
   0,     /* src_mask.  */
707
   0x000003FF,    /* dst_mask.  */
708
   false),    /* pcrel_offset.  */
709
710
711
  /* A 18-bit signed operand with the GOT offset for the address of
712
     the symbol.  */
713
  HOWTO (R_BFIN_GOT17M4,  /* type */
714
   2,     /* rightshift */
715
   2,     /* size */
716
   16,      /* bitsize */
717
   false,     /* pc_relative */
718
   0,     /* bitpos */
719
   complain_overflow_signed, /* complain_on_overflow */
720
   bfd_elf_generic_reloc, /* special_function */
721
   "R_BFIN_GOT17M4",  /* name */
722
   false,     /* partial_inplace */
723
   0xffff,    /* src_mask */
724
   0xffff,    /* dst_mask */
725
   false),    /* pcrel_offset */
726
727
  /* The upper 16 bits of the GOT offset for the address of the
728
     symbol.  */
729
  HOWTO (R_BFIN_GOTHI,    /* type */
730
   0,     /* rightshift */
731
   2,     /* size */
732
   16,      /* bitsize */
733
   false,     /* pc_relative */
734
   0,     /* bitpos */
735
   complain_overflow_dont, /* complain_on_overflow */
736
   bfd_elf_generic_reloc, /* special_function */
737
   "R_BFIN_GOTHI",    /* name */
738
   false,     /* partial_inplace */
739
   0xffff,      /* src_mask */
740
   0xffff,    /* dst_mask */
741
   false),    /* pcrel_offset */
742
743
  /* The lower 16 bits of the GOT offset for the address of the
744
     symbol.  */
745
  HOWTO (R_BFIN_GOTLO,    /* type */
746
   0,     /* rightshift */
747
   2,     /* size */
748
   16,      /* bitsize */
749
   false,     /* pc_relative */
750
   0,     /* bitpos */
751
   complain_overflow_dont, /* complain_on_overflow */
752
   bfd_elf_generic_reloc, /* special_function */
753
   "R_BFIN_GOTLO",    /* name */
754
   false,     /* partial_inplace */
755
   0xffff,    /* src_mask */
756
   0xffff,    /* dst_mask */
757
   false),    /* pcrel_offset */
758
759
  /* The 32-bit address of the canonical descriptor of a function.  */
760
  HOWTO (R_BFIN_FUNCDESC, /* type */
761
   0,     /* rightshift */
762
   4,     /* size */
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_BFIN_FUNCDESC", /* name */
769
   false,     /* partial_inplace */
770
   0xffffffff,    /* src_mask */
771
   0xffffffff,    /* dst_mask */
772
   false),    /* pcrel_offset */
773
774
  /* A 12-bit signed operand with the GOT offset for the address of
775
     canonical descriptor of a function.  */
776
  HOWTO (R_BFIN_FUNCDESC_GOT17M4, /* type */
777
   2,     /* rightshift */
778
   2,     /* size */
779
   16,      /* bitsize */
780
   false,     /* pc_relative */
781
   0,     /* bitpos */
782
   complain_overflow_signed, /* complain_on_overflow */
783
   bfd_elf_generic_reloc, /* special_function */
784
   "R_BFIN_FUNCDESC_GOT17M4", /* name */
785
   false,     /* partial_inplace */
786
   0xffff,    /* src_mask */
787
   0xffff,    /* dst_mask */
788
   false),    /* pcrel_offset */
789
790
  /* The upper 16 bits of the GOT offset for the address of the
791
     canonical descriptor of a function.  */
792
  HOWTO (R_BFIN_FUNCDESC_GOTHI, /* type */
793
   0,     /* rightshift */
794
   2,     /* size */
795
   16,      /* bitsize */
796
   false,     /* pc_relative */
797
   0,     /* bitpos */
798
   complain_overflow_dont, /* complain_on_overflow */
799
   bfd_elf_generic_reloc, /* special_function */
800
   "R_BFIN_FUNCDESC_GOTHI", /* name */
801
   false,     /* partial_inplace */
802
   0xffff,    /* src_mask */
803
   0xffff,    /* dst_mask */
804
   false),    /* pcrel_offset */
805
806
  /* The lower 16 bits of the GOT offset for the address of the
807
     canonical descriptor of a function.  */
808
  HOWTO (R_BFIN_FUNCDESC_GOTLO, /* type */
809
   0,     /* rightshift */
810
   2,     /* size */
811
   16,      /* bitsize */
812
   false,     /* pc_relative */
813
   0,     /* bitpos */
814
   complain_overflow_dont, /* complain_on_overflow */
815
   bfd_elf_generic_reloc, /* special_function */
816
   "R_BFIN_FUNCDESC_GOTLO", /* name */
817
   false,     /* partial_inplace */
818
   0xffff,    /* src_mask */
819
   0xffff,    /* dst_mask */
820
   false),    /* pcrel_offset */
821
822
  /* The 32-bit address of the canonical descriptor of a function.  */
823
  HOWTO (R_BFIN_FUNCDESC_VALUE, /* type */
824
   0,     /* rightshift */
825
   4,     /* size */
826
   64,      /* bitsize */
827
   false,     /* pc_relative */
828
   0,     /* bitpos */
829
   complain_overflow_bitfield, /* complain_on_overflow */
830
   bfd_elf_generic_reloc, /* special_function */
831
   "R_BFIN_FUNCDESC_VALUE", /* name */
832
   false,     /* partial_inplace */
833
   0xffffffff,    /* src_mask */
834
   0xffffffff,    /* dst_mask */
835
   false),    /* pcrel_offset */
836
837
  /* A 12-bit signed operand with the GOT offset for the address of
838
     canonical descriptor of a function.  */
839
  HOWTO (R_BFIN_FUNCDESC_GOTOFF17M4, /* type */
840
   2,     /* rightshift */
841
   2,     /* size */
842
   16,      /* bitsize */
843
   false,     /* pc_relative */
844
   0,     /* bitpos */
845
   complain_overflow_signed, /* complain_on_overflow */
846
   bfd_elf_generic_reloc, /* special_function */
847
   "R_BFIN_FUNCDESC_GOTOFF17M4", /* name */
848
   false,     /* partial_inplace */
849
   0xffff,    /* src_mask */
850
   0xffff,    /* dst_mask */
851
   false),    /* pcrel_offset */
852
853
  /* The upper 16 bits of the GOT offset for the address of the
854
     canonical descriptor of a function.  */
855
  HOWTO (R_BFIN_FUNCDESC_GOTOFFHI, /* type */
856
   0,     /* rightshift */
857
   2,     /* size */
858
   16,      /* bitsize */
859
   false,     /* pc_relative */
860
   0,     /* bitpos */
861
   complain_overflow_dont, /* complain_on_overflow */
862
   bfd_elf_generic_reloc, /* special_function */
863
   "R_BFIN_FUNCDESC_GOTOFFHI", /* name */
864
   false,     /* partial_inplace */
865
   0xffff,    /* src_mask */
866
   0xffff,    /* dst_mask */
867
   false),    /* pcrel_offset */
868
869
  /* The lower 16 bits of the GOT offset for the address of the
870
     canonical descriptor of a function.  */
871
  HOWTO (R_BFIN_FUNCDESC_GOTOFFLO, /* type */
872
   0,     /* rightshift */
873
   2,     /* size */
874
   16,      /* bitsize */
875
   false,     /* pc_relative */
876
   0,     /* bitpos */
877
   complain_overflow_dont, /* complain_on_overflow */
878
   bfd_elf_generic_reloc, /* special_function */
879
   "R_BFIN_FUNCDESC_GOTOFFLO", /* name */
880
   false,     /* partial_inplace */
881
   0xffff,    /* src_mask */
882
   0xffff,    /* dst_mask */
883
   false),    /* pcrel_offset */
884
885
  /* A 12-bit signed operand with the GOT offset for the address of
886
     the symbol.  */
887
  HOWTO (R_BFIN_GOTOFF17M4, /* type */
888
   2,     /* rightshift */
889
   2,     /* size */
890
   16,      /* bitsize */
891
   false,     /* pc_relative */
892
   0,     /* bitpos */
893
   complain_overflow_signed, /* complain_on_overflow */
894
   bfd_elf_generic_reloc, /* special_function */
895
   "R_BFIN_GOTOFF17M4", /* name */
896
   false,     /* partial_inplace */
897
   0xffff,    /* src_mask */
898
   0xffff,    /* dst_mask */
899
   false),    /* pcrel_offset */
900
901
  /* The upper 16 bits of the GOT offset for the address of the
902
     symbol.  */
903
  HOWTO (R_BFIN_GOTOFFHI,  /* type */
904
   0,     /* rightshift */
905
   2,     /* size */
906
   16,      /* bitsize */
907
   false,     /* pc_relative */
908
   0,     /* bitpos */
909
   complain_overflow_dont, /* complain_on_overflow */
910
   bfd_elf_generic_reloc, /* special_function */
911
   "R_BFIN_GOTOFFHI", /* name */
912
   false,     /* partial_inplace */
913
   0xffff,    /* src_mask */
914
   0xffff,    /* dst_mask */
915
   false),    /* pcrel_offset */
916
917
  /* The lower 16 bits of the GOT offset for the address of the
918
     symbol.  */
919
  HOWTO (R_BFIN_GOTOFFLO, /* type */
920
   0,     /* rightshift */
921
   2,     /* size */
922
   16,      /* bitsize */
923
   false,     /* pc_relative */
924
   0,     /* bitpos */
925
   complain_overflow_dont, /* complain_on_overflow */
926
   bfd_elf_generic_reloc, /* special_function */
927
   "R_BFIN_GOTOFFLO", /* name */
928
   false,     /* partial_inplace */
929
   0xffff,    /* src_mask */
930
   0xffff,    /* dst_mask */
931
   false),    /* pcrel_offset */
932
};
933
934
static reloc_howto_type bfin_gnuext_howto_table [] =
935
{
936
  HOWTO (R_BFIN_PLTPC,    /* type.  */
937
   0,     /* rightshift.  */
938
   2,     /* size.  */
939
   16,      /* bitsize.  */
940
   false,     /* pc_relative.  */
941
   0,     /* bitpos.  */
942
   complain_overflow_bitfield, /* complain_on_overflow.  */
943
   bfin_pltpc_reloc,  /* special_function.  */
944
   "R_BFIN_PLTPC",  /* name.  */
945
   false,     /* partial_inplace.  */
946
   0xffff,    /* src_mask.  */
947
   0xffff,    /* dst_mask.  */
948
   false),    /* pcrel_offset.  */
949
950
  HOWTO (R_BFIN_GOT,    /* type.  */
951
   0,     /* rightshift.  */
952
   2,     /* size.  */
953
   16,      /* bitsize.  */
954
   false,     /* pc_relative.  */
955
   0,     /* bitpos.  */
956
   complain_overflow_bitfield, /* complain_on_overflow.  */
957
   bfd_elf_generic_reloc, /* special_function.  */
958
   "R_BFIN_GOT",    /* name.  */
959
   false,     /* partial_inplace.  */
960
   0x7fff,    /* src_mask.  */
961
   0x7fff,    /* dst_mask.  */
962
   false),    /* pcrel_offset.  */
963
964
/* GNU extension to record C++ vtable hierarchy.  */
965
  HOWTO (R_BFIN_GNU_VTINHERIT,  /* type.  */
966
   0,     /* rightshift.  */
967
   4,     /* size.  */
968
   0,     /* bitsize.  */
969
   false,     /* pc_relative.  */
970
   0,     /* bitpos.  */
971
   complain_overflow_dont, /* complain_on_overflow.  */
972
   NULL,      /* special_function.  */
973
   "R_BFIN_GNU_VTINHERIT", /* name.  */
974
   false,     /* partial_inplace.  */
975
   0,     /* src_mask.  */
976
   0,     /* dst_mask.  */
977
   false),    /* pcrel_offset.  */
978
979
/* GNU extension to record C++ vtable member usage.  */
980
  HOWTO (R_BFIN_GNU_VTENTRY,  /* type.  */
981
   0,     /* rightshift.  */
982
   4,     /* size.  */
983
   0,     /* bitsize.  */
984
   false,     /* pc_relative.  */
985
   0,     /* bitpos.  */
986
   complain_overflow_dont, /* complain_on_overflow.  */
987
   _bfd_elf_rel_vtable_reloc_fn, /* special_function.  */
988
   "R_BFIN_GNU_VTENTRY",  /* name.  */
989
   false,     /* partial_inplace.  */
990
   0,     /* src_mask.  */
991
   0,     /* dst_mask.  */
992
   false)     /* pcrel_offset.  */
993
};
994
995
struct bfin_reloc_map
996
{
997
  bfd_reloc_code_real_type  bfd_reloc_val;
998
  unsigned int      bfin_reloc_val;
999
};
1000
1001
static const struct bfin_reloc_map bfin_reloc_map [] =
1002
{
1003
  { BFD_RELOC_NONE,     R_BFIN_UNUSED0 },
1004
  { BFD_RELOC_BFIN_5_PCREL,   R_BFIN_PCREL5M2 },
1005
  { BFD_RELOC_NONE,     R_BFIN_UNUSED1 },
1006
  { BFD_RELOC_BFIN_10_PCREL,    R_BFIN_PCREL10 },
1007
  { BFD_RELOC_BFIN_12_PCREL_JUMP, R_BFIN_PCREL12_JUMP },
1008
  { BFD_RELOC_BFIN_16_IMM,    R_BFIN_RIMM16 },
1009
  { BFD_RELOC_BFIN_16_LOW,    R_BFIN_LUIMM16 },
1010
  { BFD_RELOC_BFIN_16_HIGH,   R_BFIN_HUIMM16 },
1011
  { BFD_RELOC_BFIN_12_PCREL_JUMP_S, R_BFIN_PCREL12_JUMP_S },
1012
  { BFD_RELOC_24_PCREL,     R_BFIN_PCREL24 },
1013
  { BFD_RELOC_24_PCREL,     R_BFIN_PCREL24 },
1014
  { BFD_RELOC_BFIN_24_PCREL_JUMP_L, R_BFIN_PCREL24_JUMP_L },
1015
  { BFD_RELOC_NONE,     R_BFIN_UNUSEDB },
1016
  { BFD_RELOC_NONE,     R_BFIN_UNUSEDC },
1017
  { BFD_RELOC_BFIN_24_PCREL_CALL_X, R_BFIN_PCREL24_CALL_X },
1018
  { BFD_RELOC_8,      R_BFIN_BYTE_DATA },
1019
  { BFD_RELOC_16,     R_BFIN_BYTE2_DATA },
1020
  { BFD_RELOC_32,     R_BFIN_BYTE4_DATA },
1021
  { BFD_RELOC_BFIN_11_PCREL,    R_BFIN_PCREL11 },
1022
  { BFD_RELOC_BFIN_GOT,     R_BFIN_GOT },
1023
  { BFD_RELOC_BFIN_PLTPC,   R_BFIN_PLTPC },
1024
1025
  { BFD_RELOC_BFIN_GOT17M4,      R_BFIN_GOT17M4 },
1026
  { BFD_RELOC_BFIN_GOTHI,      R_BFIN_GOTHI },
1027
  { BFD_RELOC_BFIN_GOTLO,      R_BFIN_GOTLO },
1028
  { BFD_RELOC_BFIN_FUNCDESC,   R_BFIN_FUNCDESC },
1029
  { BFD_RELOC_BFIN_FUNCDESC_GOT17M4, R_BFIN_FUNCDESC_GOT17M4 },
1030
  { BFD_RELOC_BFIN_FUNCDESC_GOTHI, R_BFIN_FUNCDESC_GOTHI },
1031
  { BFD_RELOC_BFIN_FUNCDESC_GOTLO, R_BFIN_FUNCDESC_GOTLO },
1032
  { BFD_RELOC_BFIN_FUNCDESC_VALUE, R_BFIN_FUNCDESC_VALUE },
1033
  { BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4, R_BFIN_FUNCDESC_GOTOFF17M4 },
1034
  { BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI, R_BFIN_FUNCDESC_GOTOFFHI },
1035
  { BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO, R_BFIN_FUNCDESC_GOTOFFLO },
1036
  { BFD_RELOC_BFIN_GOTOFF17M4,   R_BFIN_GOTOFF17M4 },
1037
  { BFD_RELOC_BFIN_GOTOFFHI,   R_BFIN_GOTOFFHI },
1038
  { BFD_RELOC_BFIN_GOTOFFLO,   R_BFIN_GOTOFFLO },
1039
1040
  { BFD_RELOC_VTABLE_INHERIT,   R_BFIN_GNU_VTINHERIT },
1041
  { BFD_RELOC_VTABLE_ENTRY,   R_BFIN_GNU_VTENTRY },
1042
};
1043
1044
1045
static bool
1046
bfin_info_to_howto (bfd *abfd,
1047
        arelent *cache_ptr,
1048
        Elf_Internal_Rela *dst)
1049
0
{
1050
0
  unsigned int r_type;
1051
1052
0
  r_type = ELF32_R_TYPE (dst->r_info);
1053
1054
0
  if (r_type <= BFIN_RELOC_MAX)
1055
0
    cache_ptr->howto = &bfin_howto_table [r_type];
1056
1057
0
  else if (r_type >= BFIN_GNUEXT_RELOC_MIN && r_type <= BFIN_GNUEXT_RELOC_MAX)
1058
0
    cache_ptr->howto = &bfin_gnuext_howto_table [r_type - BFIN_GNUEXT_RELOC_MIN];
1059
1060
0
  else
1061
0
    {
1062
      /* xgettext:c-format */
1063
0
      _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1064
0
        abfd, r_type);
1065
0
      bfd_set_error (bfd_error_bad_value);
1066
0
      return false;
1067
0
    }
1068
1069
0
  return true;
1070
0
}
1071
1072
/* Given a BFD reloc type, return the howto.  */
1073
static reloc_howto_type *
1074
bfin_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
1075
          bfd_reloc_code_real_type code)
1076
0
{
1077
0
  unsigned int i;
1078
0
  unsigned int r_type = (unsigned int) -1;
1079
1080
0
  for (i = sizeof (bfin_reloc_map) / sizeof (bfin_reloc_map[0]); i--;)
1081
0
    if (bfin_reloc_map[i].bfd_reloc_val == code)
1082
0
      r_type = bfin_reloc_map[i].bfin_reloc_val;
1083
1084
0
  if (r_type <= BFIN_RELOC_MAX)
1085
0
    return &bfin_howto_table [r_type];
1086
1087
0
  else if (r_type >= BFIN_GNUEXT_RELOC_MIN && r_type <= BFIN_GNUEXT_RELOC_MAX)
1088
0
   return &bfin_gnuext_howto_table [r_type - BFIN_GNUEXT_RELOC_MIN];
1089
1090
0
  return (reloc_howto_type *) NULL;
1091
0
}
1092
1093
static reloc_howto_type *
1094
bfin_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1095
          const char *r_name)
1096
0
{
1097
0
  unsigned int i;
1098
1099
0
  for (i = 0;
1100
0
       i < (sizeof (bfin_howto_table)
1101
0
      / sizeof (bfin_howto_table[0]));
1102
0
       i++)
1103
0
    if (bfin_howto_table[i].name != NULL
1104
0
  && strcasecmp (bfin_howto_table[i].name, r_name) == 0)
1105
0
      return &bfin_howto_table[i];
1106
1107
0
  for (i = 0;
1108
0
       i < (sizeof (bfin_gnuext_howto_table)
1109
0
      / sizeof (bfin_gnuext_howto_table[0]));
1110
0
       i++)
1111
0
    if (bfin_gnuext_howto_table[i].name != NULL
1112
0
  && strcasecmp (bfin_gnuext_howto_table[i].name, r_name) == 0)
1113
0
      return &bfin_gnuext_howto_table[i];
1114
1115
0
  return NULL;
1116
0
}
1117
1118
/* Given a bfin relocation type, return the howto.  */
1119
static reloc_howto_type *
1120
bfin_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
1121
      unsigned int r_type)
1122
0
{
1123
0
  if (r_type <= BFIN_RELOC_MAX)
1124
0
    return &bfin_howto_table [r_type];
1125
1126
0
  else if (r_type >= BFIN_GNUEXT_RELOC_MIN && r_type <= BFIN_GNUEXT_RELOC_MAX)
1127
0
   return &bfin_gnuext_howto_table [r_type - BFIN_GNUEXT_RELOC_MIN];
1128
1129
0
  return (reloc_howto_type *) NULL;
1130
0
}
1131
1132
/* Set by ld emulation if --code-in-l1.  */
1133
bool elf32_bfin_code_in_l1 = 0;
1134
1135
/* Set by ld emulation if --data-in-l1.  */
1136
bool elf32_bfin_data_in_l1 = 0;
1137
1138
static bool
1139
elf32_bfin_final_write_processing (bfd *abfd)
1140
0
{
1141
0
  if (elf32_bfin_code_in_l1)
1142
0
    elf_elfheader (abfd)->e_flags |= EF_BFIN_CODE_IN_L1;
1143
0
  if (elf32_bfin_data_in_l1)
1144
0
    elf_elfheader (abfd)->e_flags |= EF_BFIN_DATA_IN_L1;
1145
0
  return _bfd_elf_final_write_processing (abfd);
1146
0
}
1147
1148
/* Return TRUE if the name is a local label.
1149
   bfin local labels begin with L$.  */
1150
static bool
1151
bfin_is_local_label_name (bfd *abfd, const char *label)
1152
0
{
1153
0
  if (label[0] == 'L' && label[1] == '$' )
1154
0
    return true;
1155
1156
0
  return _bfd_elf_is_local_label_name (abfd, label);
1157
0
}
1158

1159
/* Look through the relocs for a section during the first phase, and
1160
   allocate space in the global offset table or procedure linkage
1161
   table.  */
1162
1163
static bool
1164
bfin_check_relocs (bfd * abfd,
1165
       struct bfd_link_info *info,
1166
       asection *sec,
1167
       const Elf_Internal_Rela *relocs)
1168
0
{
1169
0
  bfd *dynobj;
1170
0
  Elf_Internal_Shdr *symtab_hdr;
1171
0
  struct elf_link_hash_entry **sym_hashes;
1172
0
  bfd_signed_vma *local_got_refcounts;
1173
0
  const Elf_Internal_Rela *rel;
1174
0
  const Elf_Internal_Rela *rel_end;
1175
0
  asection *sgot;
1176
0
  asection *srelgot;
1177
1178
0
  if (bfd_link_relocatable (info))
1179
0
    return true;
1180
1181
0
  dynobj = elf_hash_table (info)->dynobj;
1182
0
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1183
0
  sym_hashes = elf_sym_hashes (abfd);
1184
0
  local_got_refcounts = elf_local_got_refcounts (abfd);
1185
1186
0
  sgot = NULL;
1187
0
  srelgot = NULL;
1188
1189
0
  rel_end = relocs + sec->reloc_count;
1190
0
  for (rel = relocs; rel < rel_end; rel++)
1191
0
    {
1192
0
      unsigned long r_symndx;
1193
0
      struct elf_link_hash_entry *h;
1194
1195
0
      r_symndx = ELF32_R_SYM (rel->r_info);
1196
0
      if (r_symndx < symtab_hdr->sh_info)
1197
0
  h = NULL;
1198
0
      else
1199
0
  {
1200
0
    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1201
0
    while (h->root.type == bfd_link_hash_indirect
1202
0
     || h->root.type == bfd_link_hash_warning)
1203
0
      h = (struct elf_link_hash_entry *)h->root.u.i.link;
1204
0
  }
1205
1206
0
      switch (ELF32_R_TYPE (rel->r_info))
1207
0
  {
1208
       /* This relocation describes the C++ object vtable hierarchy.
1209
     Reconstruct it for later use during GC.  */
1210
0
  case R_BFIN_GNU_VTINHERIT:
1211
0
    if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1212
0
      return false;
1213
0
    break;
1214
1215
  /* This relocation describes which C++ vtable entries
1216
     are actually used.  Record for later use during GC.  */
1217
0
  case R_BFIN_GNU_VTENTRY:
1218
0
    if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1219
0
      return false;
1220
0
    break;
1221
1222
0
  case R_BFIN_GOT:
1223
0
    if (h != NULL
1224
0
        && strcmp (h->root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0)
1225
0
      break;
1226
    /* Fall through.  */
1227
1228
0
    if (dynobj == NULL)
1229
0
      {
1230
        /* Create the .got section.  */
1231
0
        elf_hash_table (info)->dynobj = dynobj = abfd;
1232
0
        if (!_bfd_elf_create_got_section (dynobj, info))
1233
0
    return false;
1234
0
      }
1235
1236
0
    sgot = elf_hash_table (info)->sgot;
1237
0
    srelgot = elf_hash_table (info)->srelgot;
1238
0
    BFD_ASSERT (sgot != NULL);
1239
1240
0
    if (h != NULL)
1241
0
      {
1242
0
        if (h->got.refcount == 0)
1243
0
    {
1244
      /* Make sure this symbol is output as a dynamic symbol.  */
1245
0
      if (h->dynindx == -1 && !h->forced_local)
1246
0
        {
1247
0
          if (!bfd_elf_link_record_dynamic_symbol (info, h))
1248
0
      return false;
1249
0
        }
1250
1251
      /* Allocate space in the .got section.  */
1252
0
      sgot->size += 4;
1253
      /* Allocate relocation space.  */
1254
0
      srelgot->size += sizeof (Elf32_External_Rela);
1255
0
    }
1256
0
        h->got.refcount++;
1257
0
      }
1258
0
    else
1259
0
      {
1260
        /* This is a global offset table entry for a local symbol.  */
1261
0
        if (local_got_refcounts == NULL)
1262
0
    {
1263
0
      bfd_size_type size;
1264
1265
0
      size = symtab_hdr->sh_info;
1266
0
      size *= sizeof (bfd_signed_vma);
1267
0
      local_got_refcounts = ((bfd_signed_vma *)
1268
0
           bfd_zalloc (abfd, size));
1269
0
      if (local_got_refcounts == NULL)
1270
0
        return false;
1271
0
      elf_local_got_refcounts (abfd) = local_got_refcounts;
1272
0
    }
1273
0
        if (local_got_refcounts[r_symndx] == 0)
1274
0
    {
1275
0
      sgot->size += 4;
1276
0
      if (bfd_link_pic (info))
1277
0
        {
1278
          /* If we are generating a shared object, we need to
1279
       output a R_68K_RELATIVE reloc so that the dynamic
1280
       linker can adjust this GOT entry.  */
1281
0
          srelgot->size += sizeof (Elf32_External_Rela);
1282
0
        }
1283
0
    }
1284
0
        local_got_refcounts[r_symndx]++;
1285
0
      }
1286
0
    break;
1287
1288
0
  default:
1289
0
    break;
1290
0
  }
1291
0
    }
1292
1293
0
  return true;
1294
0
}
1295
1296
static enum elf_reloc_type_class
1297
elf32_bfin_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1298
           const asection *rel_sec ATTRIBUTE_UNUSED,
1299
           const Elf_Internal_Rela * rela)
1300
0
{
1301
0
  switch ((int) ELF32_R_TYPE (rela->r_info))
1302
0
    {
1303
0
    default:
1304
0
      return reloc_class_normal;
1305
0
    }
1306
0
}
1307

1308
static bfd_reloc_status_type
1309
bfin_final_link_relocate (Elf_Internal_Rela *rel, reloc_howto_type *howto,
1310
        bfd *input_bfd, asection *input_section,
1311
        bfd_byte *contents, bfd_vma address,
1312
        bfd_vma value, bfd_vma addend)
1313
0
{
1314
0
  int r_type = ELF32_R_TYPE (rel->r_info);
1315
1316
0
  if (r_type == R_BFIN_PCREL24 || r_type == R_BFIN_PCREL24_JUMP_L)
1317
0
    {
1318
0
      bfd_reloc_status_type r = bfd_reloc_ok;
1319
0
      bfd_vma x;
1320
1321
0
      if (!bfd_reloc_offset_in_range (howto, input_bfd, input_section,
1322
0
              address - 2))
1323
0
    return bfd_reloc_outofrange;
1324
1325
0
      value += addend;
1326
1327
      /* Perform usual pc-relative correction.  */
1328
0
      value -= input_section->output_section->vma + input_section->output_offset;
1329
0
      value -= address;
1330
1331
      /* We are getting reloc_entry->address 2 byte off from
1332
   the start of instruction. Assuming absolute postion
1333
   of the reloc data. But, following code had been written assuming
1334
   reloc address is starting at begining of instruction.
1335
   To compensate that I have increased the value of
1336
   relocation by 1 (effectively 2) and used the addr -2 instead of addr.  */
1337
1338
0
      value += 2;
1339
0
      address -= 2;
1340
1341
0
      if ((value & 0xFF000000) != 0
1342
0
    && (value & 0xFF000000) != 0xFF000000)
1343
0
  r = bfd_reloc_overflow;
1344
1345
0
      value >>= 1;
1346
1347
0
      x = bfd_get_16 (input_bfd, contents + address);
1348
0
      x = (x & 0xff00) | ((value >> 16) & 0xff);
1349
0
      bfd_put_16 (input_bfd, x, contents + address);
1350
1351
0
      x = bfd_get_16 (input_bfd, contents + address + 2);
1352
0
      x = value & 0xFFFF;
1353
0
      bfd_put_16 (input_bfd, x, contents + address + 2);
1354
0
      return r;
1355
0
    }
1356
1357
0
  return _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
1358
0
           rel->r_offset, value, addend);
1359
1360
0
}
1361
1362
static int
1363
bfin_relocate_section (bfd * output_bfd,
1364
           struct bfd_link_info *info,
1365
           bfd * input_bfd,
1366
           asection * input_section,
1367
           bfd_byte * contents,
1368
           Elf_Internal_Rela * relocs,
1369
           Elf_Internal_Sym * local_syms,
1370
           asection ** local_sections)
1371
0
{
1372
0
  bfd *dynobj;
1373
0
  Elf_Internal_Shdr *symtab_hdr;
1374
0
  struct elf_link_hash_entry **sym_hashes;
1375
0
  bfd_vma *local_got_offsets;
1376
0
  asection *sgot;
1377
0
  Elf_Internal_Rela *rel;
1378
0
  Elf_Internal_Rela *relend;
1379
0
  int i = 0;
1380
1381
0
  dynobj = elf_hash_table (info)->dynobj;
1382
0
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1383
0
  sym_hashes = elf_sym_hashes (input_bfd);
1384
0
  local_got_offsets = elf_local_got_offsets (input_bfd);
1385
1386
0
  sgot = NULL;
1387
1388
0
  rel = relocs;
1389
0
  relend = relocs + input_section->reloc_count;
1390
0
  for (; rel < relend; rel++, i++)
1391
0
    {
1392
0
      int r_type;
1393
0
      reloc_howto_type *howto;
1394
0
      unsigned long r_symndx;
1395
0
      struct elf_link_hash_entry *h;
1396
0
      Elf_Internal_Sym *sym;
1397
0
      asection *sec;
1398
0
      bfd_vma relocation = 0;
1399
0
      bool unresolved_reloc;
1400
0
      bfd_reloc_status_type r;
1401
0
      bfd_vma address;
1402
1403
0
      r_type = ELF32_R_TYPE (rel->r_info);
1404
0
      if (r_type < 0 || r_type >= 243)
1405
0
  {
1406
0
    bfd_set_error (bfd_error_bad_value);
1407
0
    return false;
1408
0
  }
1409
1410
0
      if (r_type == R_BFIN_GNU_VTENTRY
1411
0
    || r_type == R_BFIN_GNU_VTINHERIT)
1412
0
  continue;
1413
1414
0
      howto = bfin_reloc_type_lookup (input_bfd, r_type);
1415
0
      if (howto == NULL)
1416
0
  {
1417
0
    bfd_set_error (bfd_error_bad_value);
1418
0
    return false;
1419
0
  }
1420
0
      r_symndx = ELF32_R_SYM (rel->r_info);
1421
1422
0
      h = NULL;
1423
0
      sym = NULL;
1424
0
      sec = NULL;
1425
0
      unresolved_reloc = false;
1426
1427
0
      if (r_symndx < symtab_hdr->sh_info)
1428
0
  {
1429
0
    sym = local_syms + r_symndx;
1430
0
    sec = local_sections[r_symndx];
1431
0
    relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1432
0
  }
1433
0
      else
1434
0
  {
1435
0
    bool warned, ignored;
1436
1437
0
    RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1438
0
           r_symndx, symtab_hdr, sym_hashes,
1439
0
           h, sec, relocation,
1440
0
           unresolved_reloc, warned, ignored);
1441
0
  }
1442
1443
0
      if (sec != NULL && discarded_section (sec))
1444
0
  RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1445
0
           rel, 1, relend, howto, 0, contents);
1446
1447
0
      if (bfd_link_relocatable (info))
1448
0
  continue;
1449
1450
0
      address = rel->r_offset;
1451
1452
      /* Then, process normally.  */
1453
0
      switch (r_type)
1454
0
  {
1455
0
  case R_BFIN_GNU_VTINHERIT:
1456
0
  case R_BFIN_GNU_VTENTRY:
1457
0
    return bfd_reloc_ok;
1458
1459
0
  case R_BFIN_GOT:
1460
    /* Relocation is to the address of the entry for this symbol
1461
       in the global offset table.  */
1462
0
    if (h != NULL
1463
0
        && strcmp (h->root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0)
1464
0
      goto do_default;
1465
    /* Fall through.  */
1466
    /* Relocation is the offset of the entry for this symbol in
1467
       the global offset table.  */
1468
1469
0
    {
1470
0
      bfd_vma off;
1471
1472
0
      if (dynobj == NULL)
1473
0
        {
1474
    /* Create the .got section.  */
1475
0
    elf_hash_table (info)->dynobj = dynobj = output_bfd;
1476
0
    if (!_bfd_elf_create_got_section (dynobj, info))
1477
0
      return false;
1478
0
        }
1479
1480
0
      sgot = elf_hash_table (info)->sgot;
1481
0
      BFD_ASSERT (sgot != NULL);
1482
1483
0
      if (h != NULL)
1484
0
        {
1485
0
    bool dyn;
1486
1487
0
    off = h->got.offset;
1488
0
    BFD_ASSERT (off != (bfd_vma) - 1);
1489
0
    dyn = elf_hash_table (info)->dynamic_sections_created;
1490
1491
0
    if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1492
0
                  bfd_link_pic (info),
1493
0
                  h)
1494
0
        || (bfd_link_pic (info)
1495
0
      && (info->symbolic
1496
0
          || h->dynindx == -1
1497
0
          || h->forced_local)
1498
0
      && h->def_regular))
1499
0
      {
1500
        /* This is actually a static link, or it is a
1501
           -Bsymbolic link and the symbol is defined
1502
           locally, or the symbol was forced to be local
1503
           because of a version file..  We must initialize
1504
           this entry in the global offset table.  Since
1505
           the offset must always be a multiple of 4, we
1506
           use the least significant bit to record whether
1507
           we have initialized it already.
1508
1509
           When doing a dynamic link, we create a .rela.got
1510
           relocation entry to initialize the value.  This
1511
           is done in the finish_dynamic_symbol routine.  */
1512
0
        if ((off & 1) != 0)
1513
0
          off &= ~1;
1514
0
        else
1515
0
          {
1516
0
      bfd_put_32 (output_bfd, relocation,
1517
0
            sgot->contents + off);
1518
0
      h->got.offset |= 1;
1519
0
          }
1520
0
      }
1521
0
    else
1522
0
      unresolved_reloc = false;
1523
0
        }
1524
0
      else
1525
0
        {
1526
0
    BFD_ASSERT (local_got_offsets != NULL);
1527
0
    off = local_got_offsets[r_symndx];
1528
0
    BFD_ASSERT (off != (bfd_vma) - 1);
1529
1530
    /* The offset must always be a multiple of 4.  We use
1531
       the least significant bit to record whether we have
1532
       already generated the necessary reloc.  */
1533
0
    if ((off & 1) != 0)
1534
0
      off &= ~1;
1535
0
    else
1536
0
      {
1537
0
        bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1538
1539
0
        if (bfd_link_pic (info))
1540
0
          {
1541
0
      asection *s;
1542
0
      Elf_Internal_Rela outrel;
1543
0
      bfd_byte *loc;
1544
1545
0
      s = elf_hash_table (info)->srelgot;
1546
0
      BFD_ASSERT (s != NULL);
1547
1548
0
      outrel.r_offset = (sgot->output_section->vma
1549
0
             + sgot->output_offset + off);
1550
0
      outrel.r_info =
1551
0
        ELF32_R_INFO (0, R_BFIN_PCREL24);
1552
0
      outrel.r_addend = relocation;
1553
0
      loc = s->contents;
1554
0
      loc +=
1555
0
        s->reloc_count++ * sizeof (Elf32_External_Rela);
1556
0
      bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1557
0
          }
1558
1559
0
        local_got_offsets[r_symndx] |= 1;
1560
0
      }
1561
0
        }
1562
1563
0
      relocation = sgot->output_offset + off;
1564
0
      rel->r_addend = 0;
1565
      /* bfin : preg = [preg + 17bitdiv4offset] relocation is div by 4.  */
1566
0
      relocation /= 4;
1567
0
    }
1568
0
    goto do_default;
1569
1570
0
  default:
1571
0
  do_default:
1572
0
    r = bfin_final_link_relocate (rel, howto, input_bfd, input_section,
1573
0
          contents, address,
1574
0
          relocation, rel->r_addend);
1575
1576
0
    break;
1577
0
  }
1578
1579
      /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1580
   because such sections are not SEC_ALLOC and thus ld.so will
1581
   not process them.  */
1582
0
      if (unresolved_reloc
1583
0
    && !((input_section->flags & SEC_DEBUGGING) != 0 && h->def_dynamic)
1584
0
    && _bfd_elf_section_offset (output_bfd, info, input_section,
1585
0
              rel->r_offset) != (bfd_vma) -1)
1586
0
  {
1587
0
    _bfd_error_handler
1588
      /* xgettext:c-format */
1589
0
      (_("%pB(%pA+%#" PRIx64 "): "
1590
0
         "unresolvable relocation against symbol `%s'"),
1591
0
       input_bfd, input_section, (uint64_t) rel->r_offset,
1592
0
       h->root.root.string);
1593
0
    return false;
1594
0
  }
1595
1596
0
      if (r != bfd_reloc_ok)
1597
0
  {
1598
0
    const char *name;
1599
1600
0
    if (h != NULL)
1601
0
      name = h->root.root.string;
1602
0
    else
1603
0
      {
1604
0
        name = bfd_elf_string_from_elf_section (input_bfd,
1605
0
                  symtab_hdr->sh_link,
1606
0
                  sym->st_name);
1607
0
        if (name == NULL)
1608
0
    return false;
1609
0
        if (*name == '\0')
1610
0
    name = bfd_section_name (sec);
1611
0
      }
1612
1613
0
    if (r == bfd_reloc_overflow)
1614
0
      (*info->callbacks->reloc_overflow)
1615
0
        (info, (h ? &h->root : NULL), name, howto->name,
1616
0
         (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1617
0
    else
1618
0
      {
1619
0
        _bfd_error_handler
1620
    /* xgettext:c-format */
1621
0
    (_("%pB(%pA+%#" PRIx64 "): reloc against `%s': error %d"),
1622
0
     input_bfd, input_section, (uint64_t) rel->r_offset,
1623
0
     name, (int) r);
1624
0
        return false;
1625
0
      }
1626
0
  }
1627
0
    }
1628
1629
0
  return true;
1630
0
}
1631
1632
static asection *
1633
bfin_gc_mark_hook (asection * sec,
1634
       struct bfd_link_info *info,
1635
       Elf_Internal_Rela * rel,
1636
       struct elf_link_hash_entry *h,
1637
       Elf_Internal_Sym * sym)
1638
0
{
1639
0
  if (h != NULL)
1640
0
    switch (ELF32_R_TYPE (rel->r_info))
1641
0
      {
1642
0
      case R_BFIN_GNU_VTINHERIT:
1643
0
      case R_BFIN_GNU_VTENTRY:
1644
0
  return NULL;
1645
0
      }
1646
1647
0
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1648
0
}
1649

1650
extern const bfd_target bfin_elf32_fdpic_vec;
1651
14
#define IS_FDPIC(bfd) ((bfd)->xvec == &bfin_elf32_fdpic_vec)
1652
1653
/* An extension of the elf hash table data structure,
1654
   containing some additional Blackfin-specific data.  */
1655
struct bfinfdpic_elf_link_hash_table
1656
{
1657
  struct elf_link_hash_table elf;
1658
1659
  /* A pointer to the .rofixup section.  */
1660
  asection *sgotfixup;
1661
  /* GOT base offset.  */
1662
  bfd_vma got0;
1663
  /* Location of the first non-lazy PLT entry, i.e., the number of
1664
     bytes taken by lazy PLT entries.  */
1665
  bfd_vma plt0;
1666
  /* A hash table holding information about which symbols were
1667
     referenced with which PIC-related relocations.  */
1668
  struct htab *relocs_info;
1669
  /* Summary reloc information collected by
1670
     _bfinfdpic_count_got_plt_entries.  */
1671
  struct _bfinfdpic_dynamic_got_info *g;
1672
};
1673
1674
/* Get the Blackfin ELF linker hash table from a link_info structure.  */
1675
1676
#define bfinfdpic_hash_table(p) \
1677
0
  ((is_elf_hash_table ((p)->hash)          \
1678
0
    && elf_hash_table_id (elf_hash_table (p)) == BFIN_ELF_DATA)   \
1679
0
   ? (struct bfinfdpic_elf_link_hash_table *) (p)->hash : NULL)
1680
1681
#define bfinfdpic_got_section(info) \
1682
0
  (bfinfdpic_hash_table (info)->elf.sgot)
1683
#define bfinfdpic_gotrel_section(info) \
1684
0
  (bfinfdpic_hash_table (info)->elf.srelgot)
1685
#define bfinfdpic_gotfixup_section(info) \
1686
0
  (bfinfdpic_hash_table (info)->sgotfixup)
1687
#define bfinfdpic_plt_section(info) \
1688
0
  (bfinfdpic_hash_table (info)->elf.splt)
1689
#define bfinfdpic_pltrel_section(info) \
1690
0
  (bfinfdpic_hash_table (info)->elf.srelplt)
1691
#define bfinfdpic_relocs_info(info) \
1692
0
  (bfinfdpic_hash_table (info)->relocs_info)
1693
#define bfinfdpic_got_initial_offset(info) \
1694
0
  (bfinfdpic_hash_table (info)->got0)
1695
#define bfinfdpic_plt_initial_offset(info) \
1696
0
  (bfinfdpic_hash_table (info)->plt0)
1697
#define bfinfdpic_dynamic_got_plt_info(info) \
1698
0
  (bfinfdpic_hash_table (info)->g)
1699
1700
/* The name of the dynamic interpreter.  This is put in the .interp
1701
   section.  */
1702
1703
0
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
1704
1705
0
#define DEFAULT_STACK_SIZE 0x20000
1706
1707
/* This structure is used to collect the number of entries present in
1708
   each addressable range of the got.  */
1709
struct _bfinfdpic_dynamic_got_info
1710
{
1711
  /* Several bits of information about the current link.  */
1712
  struct bfd_link_info *info;
1713
  /* Total size needed for GOT entries within the 18- or 32-bit
1714
     ranges.  */
1715
  bfd_vma got17m4, gothilo;
1716
  /* Total size needed for function descriptor entries within the 18-
1717
     or 32-bit ranges.  */
1718
  bfd_vma fd17m4, fdhilo;
1719
  /* Total size needed function descriptor entries referenced in PLT
1720
     entries, that would be profitable to place in offsets close to
1721
     the PIC register.  */
1722
  bfd_vma fdplt;
1723
  /* Total size needed by lazy PLT entries.  */
1724
  bfd_vma lzplt;
1725
  /* Number of relocations carried over from input object files.  */
1726
  unsigned long relocs;
1727
  /* Number of fixups introduced by relocations in input object files.  */
1728
  unsigned long fixups;
1729
};
1730
1731
/* Create a Blackfin ELF linker hash table.  */
1732
1733
static struct bfd_link_hash_table *
1734
bfinfdpic_elf_link_hash_table_create (bfd *abfd)
1735
0
{
1736
0
  struct bfinfdpic_elf_link_hash_table *ret;
1737
0
  size_t amt = sizeof (struct bfinfdpic_elf_link_hash_table);
1738
1739
0
  ret = bfd_zmalloc (amt);
1740
0
  if (ret == NULL)
1741
0
    return NULL;
1742
1743
0
  if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1744
0
              _bfd_elf_link_hash_newfunc,
1745
0
              sizeof (struct elf_link_hash_entry),
1746
0
              BFIN_ELF_DATA))
1747
0
    {
1748
0
      free (ret);
1749
0
      return NULL;
1750
0
    }
1751
1752
0
  return &ret->elf.root;
1753
0
}
1754
1755
/* Decide whether a reference to a symbol can be resolved locally or
1756
   not.  If the symbol is protected, we want the local address, but
1757
   its function descriptor must be assigned by the dynamic linker.  */
1758
#define BFINFDPIC_SYM_LOCAL(INFO, H) \
1759
0
  (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
1760
0
   || ! elf_hash_table (INFO)->dynamic_sections_created)
1761
#define BFINFDPIC_FUNCDESC_LOCAL(INFO, H) \
1762
0
  ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
1763
1764
/* This structure collects information on what kind of GOT, PLT or
1765
   function descriptors are required by relocations that reference a
1766
   certain symbol.  */
1767
struct bfinfdpic_relocs_info
1768
{
1769
  /* The index of the symbol, as stored in the relocation r_info, if
1770
     we have a local symbol; -1 otherwise.  */
1771
  long symndx;
1772
  union
1773
  {
1774
    /* The input bfd in which the symbol is defined, if it's a local
1775
       symbol.  */
1776
    bfd *abfd;
1777
    /* If symndx == -1, the hash table entry corresponding to a global
1778
       symbol (even if it turns out to bind locally, in which case it
1779
       should ideally be replaced with section's symndx + addend).  */
1780
    struct elf_link_hash_entry *h;
1781
  } d;
1782
  /* The addend of the relocation that references the symbol.  */
1783
  bfd_vma addend;
1784
1785
  /* The fields above are used to identify an entry.  The fields below
1786
     contain information on how an entry is used and, later on, which
1787
     locations it was assigned.  */
1788
  /* The following 2 fields record whether the symbol+addend above was
1789
     ever referenced with a GOT relocation.  The 17M4 suffix indicates a
1790
     GOT17M4 relocation; hilo is used for GOTLO/GOTHI pairs.  */
1791
  unsigned got17m4;
1792
  unsigned gothilo;
1793
  /* Whether a FUNCDESC relocation references symbol+addend.  */
1794
  unsigned fd;
1795
  /* Whether a FUNCDESC_GOT relocation references symbol+addend.  */
1796
  unsigned fdgot17m4;
1797
  unsigned fdgothilo;
1798
  /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend.  */
1799
  unsigned fdgoff17m4;
1800
  unsigned fdgoffhilo;
1801
  /* Whether symbol+addend is referenced with GOTOFF17M4, GOTOFFLO or
1802
     GOTOFFHI relocations.  The addend doesn't really matter, since we
1803
     envision that this will only be used to check whether the symbol
1804
     is mapped to the same segment as the got.  */
1805
  unsigned gotoff;
1806
  /* Whether symbol+addend is referenced by a LABEL24 relocation.  */
1807
  unsigned call;
1808
  /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
1809
     relocation.  */
1810
  unsigned sym;
1811
  /* Whether we need a PLT entry for a symbol.  Should be implied by
1812
     something like:
1813
     (call && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h))  */
1814
  unsigned plt:1;
1815
  /* Whether a function descriptor should be created in this link unit
1816
     for symbol+addend.  Should be implied by something like:
1817
     (plt || fdgotoff17m4 || fdgotofflohi
1818
      || ((fd || fdgot17m4 || fdgothilo)
1819
    && (symndx != -1 || BFINFDPIC_FUNCDESC_LOCAL (info, d.h))))  */
1820
  unsigned privfd:1;
1821
  /* Whether a lazy PLT entry is needed for this symbol+addend.
1822
     Should be implied by something like:
1823
     (privfd && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)
1824
      && ! (info->flags & DF_BIND_NOW))  */
1825
  unsigned lazyplt:1;
1826
  /* Whether we've already emitted GOT relocations and PLT entries as
1827
     needed for this symbol.  */
1828
  unsigned done:1;
1829
1830
  /* The number of R_BFIN_BYTE4_DATA, R_BFIN_FUNCDESC and R_BFIN_FUNCDESC_VALUE
1831
     relocations referencing the symbol.  */
1832
  unsigned relocs32, relocsfd, relocsfdv;
1833
1834
  /* The number of .rofixups entries and dynamic relocations allocated
1835
     for this symbol, minus any that might have already been used.  */
1836
  unsigned fixups, dynrelocs;
1837
1838
  /* The offsets of the GOT entries assigned to symbol+addend, to the
1839
     function descriptor's address, and to a function descriptor,
1840
     respectively.  Should be zero if unassigned.  The offsets are
1841
     counted from the value that will be assigned to the PIC register,
1842
     not from the beginning of the .got section.  */
1843
  bfd_signed_vma got_entry, fdgot_entry, fd_entry;
1844
  /* The offsets of the PLT entries assigned to symbol+addend,
1845
     non-lazy and lazy, respectively.  If unassigned, should be
1846
     (bfd_vma)-1.  */
1847
  bfd_vma plt_entry, lzplt_entry;
1848
};
1849
1850
/* Compute a hash with the key fields of an bfinfdpic_relocs_info entry.  */
1851
static hashval_t
1852
bfinfdpic_relocs_info_hash (const void *entry_)
1853
0
{
1854
0
  const struct bfinfdpic_relocs_info *entry = entry_;
1855
1856
0
  return (entry->symndx == -1
1857
0
    ? (long) entry->d.h->root.root.hash
1858
0
    : entry->symndx + (long) entry->d.abfd->id * 257) + entry->addend;
1859
0
}
1860
1861
/* Test whether the key fields of two bfinfdpic_relocs_info entries are
1862
   identical.  */
1863
static int
1864
bfinfdpic_relocs_info_eq (const void *entry1, const void *entry2)
1865
0
{
1866
0
  const struct bfinfdpic_relocs_info *e1 = entry1;
1867
0
  const struct bfinfdpic_relocs_info *e2 = entry2;
1868
1869
0
  return e1->symndx == e2->symndx && e1->addend == e2->addend
1870
0
    && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd);
1871
0
}
1872
1873
/* Find or create an entry in a hash table HT that matches the key
1874
   fields of the given ENTRY.  If it's not found, memory for a new
1875
   entry is allocated in ABFD's obstack.  */
1876
static struct bfinfdpic_relocs_info *
1877
bfinfdpic_relocs_info_find (struct htab *ht,
1878
         bfd *abfd,
1879
         const struct bfinfdpic_relocs_info *entry,
1880
         enum insert_option insert)
1881
0
{
1882
0
  struct bfinfdpic_relocs_info **loc;
1883
1884
0
  if (!ht)
1885
0
    return NULL;
1886
1887
0
  loc = (struct bfinfdpic_relocs_info **) htab_find_slot (ht, entry, insert);
1888
1889
0
  if (! loc)
1890
0
    return NULL;
1891
1892
0
  if (*loc)
1893
0
    return *loc;
1894
1895
0
  *loc = bfd_zalloc (abfd, sizeof (**loc));
1896
1897
0
  if (! *loc)
1898
0
    return *loc;
1899
1900
0
  (*loc)->symndx = entry->symndx;
1901
0
  (*loc)->d = entry->d;
1902
0
  (*loc)->addend = entry->addend;
1903
0
  (*loc)->plt_entry = (bfd_vma)-1;
1904
0
  (*loc)->lzplt_entry = (bfd_vma)-1;
1905
1906
0
  return *loc;
1907
0
}
1908
1909
/* Obtain the address of the entry in HT associated with H's symbol +
1910
   addend, creating a new entry if none existed.  ABFD is only used
1911
   for memory allocation purposes.  */
1912
inline static struct bfinfdpic_relocs_info *
1913
bfinfdpic_relocs_info_for_global (struct htab *ht,
1914
          bfd *abfd,
1915
          struct elf_link_hash_entry *h,
1916
          bfd_vma addend,
1917
          enum insert_option insert)
1918
0
{
1919
0
  struct bfinfdpic_relocs_info entry;
1920
1921
0
  entry.symndx = -1;
1922
0
  entry.d.h = h;
1923
0
  entry.addend = addend;
1924
1925
0
  return bfinfdpic_relocs_info_find (ht, abfd, &entry, insert);
1926
0
}
1927
1928
/* Obtain the address of the entry in HT associated with the SYMNDXth
1929
   local symbol of the input bfd ABFD, plus the addend, creating a new
1930
   entry if none existed.  */
1931
inline static struct bfinfdpic_relocs_info *
1932
bfinfdpic_relocs_info_for_local (struct htab *ht,
1933
        bfd *abfd,
1934
        long symndx,
1935
        bfd_vma addend,
1936
        enum insert_option insert)
1937
0
{
1938
0
  struct bfinfdpic_relocs_info entry;
1939
1940
0
  entry.symndx = symndx;
1941
0
  entry.d.abfd = abfd;
1942
0
  entry.addend = addend;
1943
1944
0
  return bfinfdpic_relocs_info_find (ht, abfd, &entry, insert);
1945
0
}
1946
1947
/* Merge fields set by check_relocs() of two entries that end up being
1948
   mapped to the same (presumably global) symbol.  */
1949
1950
inline static void
1951
bfinfdpic_pic_merge_early_relocs_info (struct bfinfdpic_relocs_info *e2,
1952
               struct bfinfdpic_relocs_info const *e1)
1953
0
{
1954
0
  e2->got17m4 |= e1->got17m4;
1955
0
  e2->gothilo |= e1->gothilo;
1956
0
  e2->fd |= e1->fd;
1957
0
  e2->fdgot17m4 |= e1->fdgot17m4;
1958
0
  e2->fdgothilo |= e1->fdgothilo;
1959
0
  e2->fdgoff17m4 |= e1->fdgoff17m4;
1960
0
  e2->fdgoffhilo |= e1->fdgoffhilo;
1961
0
  e2->gotoff |= e1->gotoff;
1962
0
  e2->call |= e1->call;
1963
0
  e2->sym |= e1->sym;
1964
0
}
1965
1966
/* Every block of 65535 lazy PLT entries shares a single call to the
1967
   resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
1968
   32767, counting from 0).  All other lazy PLT entries branch to it
1969
   in a single instruction.  */
1970
1971
0
#define LZPLT_RESOLVER_EXTRA 10
1972
0
#define LZPLT_NORMAL_SIZE 6
1973
0
#define LZPLT_ENTRIES 1362
1974
1975
0
#define BFINFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) LZPLT_NORMAL_SIZE * LZPLT_ENTRIES + LZPLT_RESOLVER_EXTRA)
1976
0
#define BFINFDPIC_LZPLT_RESOLV_LOC (LZPLT_NORMAL_SIZE * LZPLT_ENTRIES / 2)
1977
1978
/* Add a dynamic relocation to the SRELOC section.  */
1979
1980
inline static bfd_vma
1981
_bfinfdpic_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
1982
       int reloc_type, long dynindx, bfd_vma addend,
1983
       struct bfinfdpic_relocs_info *entry)
1984
0
{
1985
0
  Elf_Internal_Rela outrel;
1986
0
  bfd_vma reloc_offset;
1987
1988
0
  outrel.r_offset = offset;
1989
0
  outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
1990
0
  outrel.r_addend = addend;
1991
1992
0
  reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel);
1993
0
  BFD_ASSERT (reloc_offset < sreloc->size);
1994
0
  bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1995
0
          sreloc->contents + reloc_offset);
1996
0
  sreloc->reloc_count++;
1997
1998
  /* If the entry's index is zero, this relocation was probably to a
1999
     linkonce section that got discarded.  We reserved a dynamic
2000
     relocation, but it was for another entry than the one we got at
2001
     the time of emitting the relocation.  Unfortunately there's no
2002
     simple way for us to catch this situation, since the relocation
2003
     is cleared right before calling relocate_section, at which point
2004
     we no longer know what the relocation used to point to.  */
2005
0
  if (entry->symndx)
2006
0
    {
2007
0
      BFD_ASSERT (entry->dynrelocs > 0);
2008
0
      entry->dynrelocs--;
2009
0
    }
2010
2011
0
  return reloc_offset;
2012
0
}
2013
2014
/* Add a fixup to the ROFIXUP section.  */
2015
2016
static bfd_vma
2017
_bfinfdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset,
2018
      struct bfinfdpic_relocs_info *entry)
2019
0
{
2020
0
  bfd_vma fixup_offset;
2021
2022
0
  if (rofixup->flags & SEC_EXCLUDE)
2023
0
    return -1;
2024
2025
0
  fixup_offset = rofixup->reloc_count * 4;
2026
0
  if (rofixup->contents)
2027
0
    {
2028
0
      BFD_ASSERT (fixup_offset < rofixup->size);
2029
0
      bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset);
2030
0
    }
2031
0
  rofixup->reloc_count++;
2032
2033
0
  if (entry && entry->symndx)
2034
0
    {
2035
      /* See discussion about symndx == 0 in _bfinfdpic_add_dyn_reloc
2036
   above.  */
2037
0
      BFD_ASSERT (entry->fixups > 0);
2038
0
      entry->fixups--;
2039
0
    }
2040
2041
0
  return fixup_offset;
2042
0
}
2043
2044
/* Find the segment number in which OSEC, and output section, is
2045
   located.  */
2046
2047
static unsigned
2048
_bfinfdpic_osec_to_segment (bfd *output_bfd, asection *osec)
2049
0
{
2050
0
  Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section (output_bfd, osec);
2051
2052
0
  return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1;
2053
0
}
2054
2055
inline static bool
2056
_bfinfdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
2057
0
{
2058
0
  unsigned seg = _bfinfdpic_osec_to_segment (output_bfd, osec);
2059
2060
0
  return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
2061
0
}
2062
2063
/* Generate relocations for GOT entries, function descriptors, and
2064
   code for PLT and lazy PLT entries.  */
2065
2066
inline static bool
2067
_bfinfdpic_emit_got_relocs_plt_entries (struct bfinfdpic_relocs_info *entry,
2068
          bfd *output_bfd,
2069
          struct bfd_link_info *info,
2070
          asection *sec,
2071
          Elf_Internal_Sym *sym,
2072
          bfd_vma addend)
2073
0
{
2074
0
  bfd_vma fd_lazy_rel_offset = (bfd_vma) -1;
2075
0
  int dynindx = -1;
2076
2077
0
  if (entry->done)
2078
0
    return true;
2079
0
  entry->done = 1;
2080
2081
0
  if (entry->got_entry || entry->fdgot_entry || entry->fd_entry)
2082
0
    {
2083
      /* If the symbol is dynamic, consider it for dynamic
2084
   relocations, otherwise decay to section + offset.  */
2085
0
      if (entry->symndx == -1 && entry->d.h->dynindx != -1)
2086
0
  dynindx = entry->d.h->dynindx;
2087
0
      else
2088
0
  {
2089
0
    if (sec
2090
0
        && sec->output_section
2091
0
        && ! bfd_is_abs_section (sec->output_section)
2092
0
        && ! bfd_is_und_section (sec->output_section))
2093
0
      dynindx = elf_section_data (sec->output_section)->dynindx;
2094
0
    else
2095
0
      dynindx = 0;
2096
0
  }
2097
0
    }
2098
2099
  /* Generate relocation for GOT entry pointing to the symbol.  */
2100
0
  if (entry->got_entry)
2101
0
    {
2102
0
      int idx = dynindx;
2103
0
      bfd_vma ad = addend;
2104
2105
      /* If the symbol is dynamic but binds locally, use
2106
   section+offset.  */
2107
0
      if (sec && (entry->symndx != -1
2108
0
      || BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
2109
0
  {
2110
0
    if (entry->symndx == -1)
2111
0
      ad += entry->d.h->root.u.def.value;
2112
0
    else
2113
0
      ad += sym->st_value;
2114
0
    ad += sec->output_offset;
2115
0
    if (sec->output_section && elf_section_data (sec->output_section))
2116
0
      idx = elf_section_data (sec->output_section)->dynindx;
2117
0
    else
2118
0
      idx = 0;
2119
0
  }
2120
2121
      /* If we're linking an executable at a fixed address, we can
2122
   omit the dynamic relocation as long as the symbol is local to
2123
   this module.  */
2124
0
      if (bfd_link_pde (info)
2125
0
    && (entry->symndx != -1
2126
0
        || BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
2127
0
  {
2128
0
    if (sec)
2129
0
      ad += sec->output_section->vma;
2130
0
    if (entry->symndx != -1
2131
0
        || entry->d.h->root.type != bfd_link_hash_undefweak)
2132
0
      _bfinfdpic_add_rofixup (output_bfd,
2133
0
           bfinfdpic_gotfixup_section (info),
2134
0
           bfinfdpic_got_section (info)->output_section
2135
0
           ->vma
2136
0
           + bfinfdpic_got_section (info)->output_offset
2137
0
           + bfinfdpic_got_initial_offset (info)
2138
0
           + entry->got_entry, entry);
2139
0
  }
2140
0
      else
2141
0
  _bfinfdpic_add_dyn_reloc (output_bfd, bfinfdpic_gotrel_section (info),
2142
0
         _bfd_elf_section_offset
2143
0
         (output_bfd, info,
2144
0
          bfinfdpic_got_section (info),
2145
0
          bfinfdpic_got_initial_offset (info)
2146
0
          + entry->got_entry)
2147
0
         + bfinfdpic_got_section (info)
2148
0
         ->output_section->vma
2149
0
         + bfinfdpic_got_section (info)->output_offset,
2150
0
         R_BFIN_BYTE4_DATA, idx, ad, entry);
2151
2152
0
      bfd_put_32 (output_bfd, ad,
2153
0
      bfinfdpic_got_section (info)->contents
2154
0
      + bfinfdpic_got_initial_offset (info)
2155
0
      + entry->got_entry);
2156
0
    }
2157
2158
  /* Generate relocation for GOT entry pointing to a canonical
2159
     function descriptor.  */
2160
0
  if (entry->fdgot_entry)
2161
0
    {
2162
0
      int reloc, idx;
2163
0
      bfd_vma ad = 0;
2164
2165
0
      if (! (entry->symndx == -1
2166
0
       && entry->d.h->root.type == bfd_link_hash_undefweak
2167
0
       && BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
2168
0
  {
2169
    /* If the symbol is dynamic and there may be dynamic symbol
2170
       resolution because we are, or are linked with, a shared
2171
       library, emit a FUNCDESC relocation such that the dynamic
2172
       linker will allocate the function descriptor.  If the
2173
       symbol needs a non-local function descriptor but binds
2174
       locally (e.g., its visibility is protected, emit a
2175
       dynamic relocation decayed to section+offset.  */
2176
0
    if (entry->symndx == -1
2177
0
        && ! BFINFDPIC_FUNCDESC_LOCAL (info, entry->d.h)
2178
0
        && BFINFDPIC_SYM_LOCAL (info, entry->d.h)
2179
0
        && !bfd_link_pde (info))
2180
0
      {
2181
0
        reloc = R_BFIN_FUNCDESC;
2182
0
        idx = elf_section_data (entry->d.h->root.u.def.section
2183
0
              ->output_section)->dynindx;
2184
0
        ad = entry->d.h->root.u.def.section->output_offset
2185
0
    + entry->d.h->root.u.def.value;
2186
0
      }
2187
0
    else if (entry->symndx == -1
2188
0
       && ! BFINFDPIC_FUNCDESC_LOCAL (info, entry->d.h))
2189
0
      {
2190
0
        reloc = R_BFIN_FUNCDESC;
2191
0
        idx = dynindx;
2192
0
        ad = addend;
2193
0
        if (ad)
2194
0
    return false;
2195
0
      }
2196
0
    else
2197
0
      {
2198
        /* Otherwise, we know we have a private function descriptor,
2199
     so reference it directly.  */
2200
0
        if (elf_hash_table (info)->dynamic_sections_created)
2201
0
    BFD_ASSERT (entry->privfd);
2202
0
        reloc = R_BFIN_BYTE4_DATA;
2203
0
        idx = elf_section_data (bfinfdpic_got_section (info)
2204
0
              ->output_section)->dynindx;
2205
0
        ad = bfinfdpic_got_section (info)->output_offset
2206
0
    + bfinfdpic_got_initial_offset (info) + entry->fd_entry;
2207
0
      }
2208
2209
    /* If there is room for dynamic symbol resolution, emit the
2210
       dynamic relocation.  However, if we're linking an
2211
       executable at a fixed location, we won't have emitted a
2212
       dynamic symbol entry for the got section, so idx will be
2213
       zero, which means we can and should compute the address
2214
       of the private descriptor ourselves.  */
2215
0
    if (bfd_link_pde (info)
2216
0
        && (entry->symndx != -1
2217
0
      || BFINFDPIC_FUNCDESC_LOCAL (info, entry->d.h)))
2218
0
      {
2219
0
        ad += bfinfdpic_got_section (info)->output_section->vma;
2220
0
        _bfinfdpic_add_rofixup (output_bfd,
2221
0
             bfinfdpic_gotfixup_section (info),
2222
0
             bfinfdpic_got_section (info)
2223
0
             ->output_section->vma
2224
0
             + bfinfdpic_got_section (info)
2225
0
             ->output_offset
2226
0
             + bfinfdpic_got_initial_offset (info)
2227
0
             + entry->fdgot_entry, entry);
2228
0
      }
2229
0
    else
2230
0
      _bfinfdpic_add_dyn_reloc (output_bfd,
2231
0
             bfinfdpic_gotrel_section (info),
2232
0
             _bfd_elf_section_offset
2233
0
             (output_bfd, info,
2234
0
              bfinfdpic_got_section (info),
2235
0
              bfinfdpic_got_initial_offset (info)
2236
0
              + entry->fdgot_entry)
2237
0
             + bfinfdpic_got_section (info)
2238
0
             ->output_section->vma
2239
0
             + bfinfdpic_got_section (info)
2240
0
             ->output_offset,
2241
0
             reloc, idx, ad, entry);
2242
0
  }
2243
2244
0
      bfd_put_32 (output_bfd, ad,
2245
0
      bfinfdpic_got_section (info)->contents
2246
0
      + bfinfdpic_got_initial_offset (info)
2247
0
      + entry->fdgot_entry);
2248
0
    }
2249
2250
  /* Generate relocation to fill in a private function descriptor in
2251
     the GOT.  */
2252
0
  if (entry->fd_entry)
2253
0
    {
2254
0
      int idx = dynindx;
2255
0
      bfd_vma ad = addend;
2256
0
      bfd_vma ofst;
2257
0
      long lowword, highword;
2258
2259
      /* If the symbol is dynamic but binds locally, use
2260
   section+offset.  */
2261
0
      if (sec && (entry->symndx != -1
2262
0
      || BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
2263
0
  {
2264
0
    if (entry->symndx == -1)
2265
0
      ad += entry->d.h->root.u.def.value;
2266
0
    else
2267
0
      ad += sym->st_value;
2268
0
    ad += sec->output_offset;
2269
0
    if (sec->output_section && elf_section_data (sec->output_section))
2270
0
      idx = elf_section_data (sec->output_section)->dynindx;
2271
0
    else
2272
0
      idx = 0;
2273
0
  }
2274
2275
      /* If we're linking an executable at a fixed address, we can
2276
   omit the dynamic relocation as long as the symbol is local to
2277
   this module.  */
2278
0
      if (bfd_link_pde (info)
2279
0
    && (entry->symndx != -1 || BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
2280
0
  {
2281
0
    if (sec)
2282
0
      ad += sec->output_section->vma;
2283
0
    ofst = 0;
2284
0
    if (entry->symndx != -1
2285
0
        || entry->d.h->root.type != bfd_link_hash_undefweak)
2286
0
      {
2287
0
        _bfinfdpic_add_rofixup (output_bfd,
2288
0
             bfinfdpic_gotfixup_section (info),
2289
0
             bfinfdpic_got_section (info)
2290
0
             ->output_section->vma
2291
0
             + bfinfdpic_got_section (info)
2292
0
             ->output_offset
2293
0
             + bfinfdpic_got_initial_offset (info)
2294
0
             + entry->fd_entry, entry);
2295
0
        _bfinfdpic_add_rofixup (output_bfd,
2296
0
             bfinfdpic_gotfixup_section (info),
2297
0
             bfinfdpic_got_section (info)
2298
0
             ->output_section->vma
2299
0
             + bfinfdpic_got_section (info)
2300
0
             ->output_offset
2301
0
             + bfinfdpic_got_initial_offset (info)
2302
0
             + entry->fd_entry + 4, entry);
2303
0
      }
2304
0
  }
2305
0
      else
2306
0
  {
2307
0
    ofst
2308
0
      = _bfinfdpic_add_dyn_reloc (output_bfd,
2309
0
          entry->lazyplt
2310
0
          ? bfinfdpic_pltrel_section (info)
2311
0
          : bfinfdpic_gotrel_section (info),
2312
0
          _bfd_elf_section_offset
2313
0
          (output_bfd, info,
2314
0
           bfinfdpic_got_section (info),
2315
0
           bfinfdpic_got_initial_offset (info)
2316
0
           + entry->fd_entry)
2317
0
          + bfinfdpic_got_section (info)
2318
0
          ->output_section->vma
2319
0
          + bfinfdpic_got_section (info)
2320
0
          ->output_offset,
2321
0
          R_BFIN_FUNCDESC_VALUE, idx, ad, entry);
2322
0
  }
2323
2324
      /* If we've omitted the dynamic relocation, just emit the fixed
2325
   addresses of the symbol and of the local GOT base offset.  */
2326
0
      if (bfd_link_pde (info)
2327
0
    && sec
2328
0
    && sec->output_section)
2329
0
  {
2330
0
    lowword = ad;
2331
0
    highword = bfinfdpic_got_section (info)->output_section->vma
2332
0
      + bfinfdpic_got_section (info)->output_offset
2333
0
      + bfinfdpic_got_initial_offset (info);
2334
0
  }
2335
0
      else if (entry->lazyplt)
2336
0
  {
2337
0
    if (ad)
2338
0
      return false;
2339
2340
0
    fd_lazy_rel_offset = ofst;
2341
2342
    /* A function descriptor used for lazy or local resolving is
2343
       initialized such that its high word contains the output
2344
       section index in which the PLT entries are located, and
2345
       the low word contains the address of the lazy PLT entry
2346
       entry point, that must be within the memory region
2347
       assigned to that section.  */
2348
0
    lowword = entry->lzplt_entry + 4
2349
0
      + bfinfdpic_plt_section (info)->output_offset
2350
0
      + bfinfdpic_plt_section (info)->output_section->vma;
2351
0
    highword = _bfinfdpic_osec_to_segment
2352
0
      (output_bfd, bfinfdpic_plt_section (info)->output_section);
2353
0
  }
2354
0
      else
2355
0
  {
2356
    /* A function descriptor for a local function gets the index
2357
       of the section.  For a non-local function, it's
2358
       disregarded.  */
2359
0
    lowword = ad;
2360
0
    if (sec == NULL
2361
0
        || (entry->symndx == -1 && entry->d.h->dynindx != -1
2362
0
      && entry->d.h->dynindx == idx))
2363
0
      highword = 0;
2364
0
    else
2365
0
      highword = _bfinfdpic_osec_to_segment
2366
0
        (output_bfd, sec->output_section);
2367
0
  }
2368
2369
0
      bfd_put_32 (output_bfd, lowword,
2370
0
      bfinfdpic_got_section (info)->contents
2371
0
      + bfinfdpic_got_initial_offset (info)
2372
0
      + entry->fd_entry);
2373
0
      bfd_put_32 (output_bfd, highword,
2374
0
      bfinfdpic_got_section (info)->contents
2375
0
      + bfinfdpic_got_initial_offset (info)
2376
0
      + entry->fd_entry + 4);
2377
0
    }
2378
2379
  /* Generate code for the PLT entry.  */
2380
0
  if (entry->plt_entry != (bfd_vma) -1)
2381
0
    {
2382
0
      bfd_byte *plt_code = bfinfdpic_plt_section (info)->contents
2383
0
  + entry->plt_entry;
2384
2385
0
      BFD_ASSERT (entry->fd_entry);
2386
2387
      /* Figure out what kind of PLT entry we need, depending on the
2388
   location of the function descriptor within the GOT.  */
2389
0
      if (entry->fd_entry >= -(1 << (18 - 1))
2390
0
    && entry->fd_entry + 4 < (1 << (18 - 1)))
2391
0
  {
2392
    /* P1 = [P3 + fd_entry]; P3 = [P3 + fd_entry + 4] */
2393
0
    bfd_put_32 (output_bfd,
2394
0
          0xe519 | ((entry->fd_entry << 14) & 0xFFFF0000),
2395
0
          plt_code);
2396
0
    bfd_put_32 (output_bfd,
2397
0
          0xe51b | (((entry->fd_entry + 4) << 14) & 0xFFFF0000),
2398
0
          plt_code + 4);
2399
0
    plt_code += 8;
2400
0
  }
2401
0
      else
2402
0
  {
2403
    /* P1.L = fd_entry; P1.H = fd_entry;
2404
       P3 = P3 + P1;
2405
       P1 = [P3];
2406
       P3 = [P3 + 4];  */
2407
0
    bfd_put_32 (output_bfd,
2408
0
          0xe109 | (entry->fd_entry << 16),
2409
0
          plt_code);
2410
0
    bfd_put_32 (output_bfd,
2411
0
          0xe149 | (entry->fd_entry & 0xFFFF0000),
2412
0
          plt_code + 4);
2413
0
    bfd_put_16 (output_bfd, 0x5ad9, plt_code + 8);
2414
0
    bfd_put_16 (output_bfd, 0x9159, plt_code + 10);
2415
0
    bfd_put_16 (output_bfd, 0xac5b, plt_code + 12);
2416
0
    plt_code += 14;
2417
0
  }
2418
      /* JUMP (P1) */
2419
0
      bfd_put_16 (output_bfd, 0x0051, plt_code);
2420
0
    }
2421
2422
  /* Generate code for the lazy PLT entry.  */
2423
0
  if (entry->lzplt_entry != (bfd_vma) -1)
2424
0
    {
2425
0
      bfd_byte *lzplt_code = bfinfdpic_plt_section (info)->contents
2426
0
  + entry->lzplt_entry;
2427
0
      bfd_vma resolverStub_addr;
2428
2429
0
      bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code);
2430
0
      lzplt_code += 4;
2431
2432
0
      resolverStub_addr = entry->lzplt_entry / BFINFDPIC_LZPLT_BLOCK_SIZE
2433
0
  * BFINFDPIC_LZPLT_BLOCK_SIZE + BFINFDPIC_LZPLT_RESOLV_LOC;
2434
0
      if (resolverStub_addr >= bfinfdpic_plt_initial_offset (info))
2435
0
  resolverStub_addr = bfinfdpic_plt_initial_offset (info) - LZPLT_NORMAL_SIZE - LZPLT_RESOLVER_EXTRA;
2436
2437
0
      if (entry->lzplt_entry == resolverStub_addr)
2438
0
  {
2439
    /* This is a lazy PLT entry that includes a resolver call.
2440
       P2 = [P3];
2441
       R3 = [P3 + 4];
2442
       JUMP (P2);  */
2443
0
    bfd_put_32 (output_bfd,
2444
0
          0xa05b915a,
2445
0
          lzplt_code);
2446
0
    bfd_put_16 (output_bfd, 0x0052, lzplt_code + 4);
2447
0
  }
2448
0
      else
2449
0
  {
2450
    /* JUMP.S  resolverStub */
2451
0
    bfd_put_16 (output_bfd,
2452
0
          0x2000
2453
0
          | (((resolverStub_addr - entry->lzplt_entry)
2454
0
        / 2) & (((bfd_vma)1 << 12) - 1)),
2455
0
          lzplt_code);
2456
0
  }
2457
0
    }
2458
2459
0
  return true;
2460
0
}
2461

2462
/* Relocate an Blackfin ELF section.
2463
2464
   The RELOCATE_SECTION function is called by the new ELF backend linker
2465
   to handle the relocations for a section.
2466
2467
   The relocs are always passed as Rela structures; if the section
2468
   actually uses Rel structures, the r_addend field will always be
2469
   zero.
2470
2471
   This function is responsible for adjusting the section contents as
2472
   necessary, and (if using Rela relocs and generating a relocatable
2473
   output file) adjusting the reloc addend as necessary.
2474
2475
   This function does not have to worry about setting the reloc
2476
   address or the reloc symbol index.
2477
2478
   LOCAL_SYMS is a pointer to the swapped in local symbols.
2479
2480
   LOCAL_SECTIONS is an array giving the section in the input file
2481
   corresponding to the st_shndx field of each local symbol.
2482
2483
   The global hash table entry for the global symbols can be found
2484
   via elf_sym_hashes (input_bfd).
2485
2486
   When generating relocatable output, this function must handle
2487
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2488
   going to be the section symbol corresponding to the output
2489
   section, which means that the addend must be adjusted
2490
   accordingly.  */
2491
2492
static int
2493
bfinfdpic_relocate_section (bfd * output_bfd,
2494
          struct bfd_link_info *info,
2495
          bfd * input_bfd,
2496
          asection * input_section,
2497
          bfd_byte * contents,
2498
          Elf_Internal_Rela * relocs,
2499
          Elf_Internal_Sym * local_syms,
2500
          asection ** local_sections)
2501
0
{
2502
0
  Elf_Internal_Shdr *symtab_hdr;
2503
0
  struct elf_link_hash_entry **sym_hashes;
2504
0
  Elf_Internal_Rela *rel;
2505
0
  Elf_Internal_Rela *relend;
2506
0
  unsigned isec_segment, got_segment, plt_segment,
2507
0
    check_segment[2];
2508
0
  int silence_segment_error = !bfd_link_pic (info);
2509
2510
0
  symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2511
0
  sym_hashes = elf_sym_hashes (input_bfd);
2512
0
  relend     = relocs + input_section->reloc_count;
2513
2514
0
  isec_segment = _bfinfdpic_osec_to_segment (output_bfd,
2515
0
               input_section->output_section);
2516
0
  if (IS_FDPIC (output_bfd) && bfinfdpic_got_section (info))
2517
0
    got_segment = _bfinfdpic_osec_to_segment (output_bfd,
2518
0
                bfinfdpic_got_section (info)
2519
0
                ->output_section);
2520
0
  else
2521
0
    got_segment = -1;
2522
0
  if (IS_FDPIC (output_bfd) && elf_hash_table (info)->dynamic_sections_created)
2523
0
    plt_segment = _bfinfdpic_osec_to_segment (output_bfd,
2524
0
                bfinfdpic_plt_section (info)
2525
0
                ->output_section);
2526
0
  else
2527
0
    plt_segment = -1;
2528
2529
0
  for (rel = relocs; rel < relend; rel ++)
2530
0
    {
2531
0
      reloc_howto_type *howto;
2532
0
      unsigned long r_symndx;
2533
0
      Elf_Internal_Sym *sym;
2534
0
      asection *sec;
2535
0
      struct elf_link_hash_entry *h;
2536
0
      bfd_vma relocation;
2537
0
      bfd_reloc_status_type r;
2538
0
      const char * name = NULL;
2539
0
      int r_type;
2540
0
      asection *osec;
2541
0
      struct bfinfdpic_relocs_info *picrel;
2542
0
      bfd_vma orig_addend = rel->r_addend;
2543
2544
0
      r_type = ELF32_R_TYPE (rel->r_info);
2545
2546
0
      if (r_type == R_BFIN_GNU_VTINHERIT
2547
0
    || r_type == R_BFIN_GNU_VTENTRY)
2548
0
  continue;
2549
2550
0
      r_symndx = ELF32_R_SYM (rel->r_info);
2551
0
      howto = bfin_reloc_type_lookup (input_bfd, r_type);
2552
0
      if (howto == NULL)
2553
0
  {
2554
0
    bfd_set_error (bfd_error_bad_value);
2555
0
    return false;
2556
0
  }
2557
2558
0
      h      = NULL;
2559
0
      sym    = NULL;
2560
0
      sec    = NULL;
2561
0
      picrel = NULL;
2562
2563
0
      if (r_symndx < symtab_hdr->sh_info)
2564
0
  {
2565
0
    sym = local_syms + r_symndx;
2566
0
    osec = sec = local_sections [r_symndx];
2567
0
    relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2568
2569
0
    name = bfd_elf_string_from_elf_section
2570
0
      (input_bfd, symtab_hdr->sh_link, sym->st_name);
2571
0
    name = name == NULL ? bfd_section_name (sec) : name;
2572
0
  }
2573
0
      else
2574
0
  {
2575
0
    bool warned, ignored;
2576
0
    bool unresolved_reloc;
2577
2578
0
    RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2579
0
           r_symndx, symtab_hdr, sym_hashes,
2580
0
           h, sec, relocation,
2581
0
           unresolved_reloc, warned, ignored);
2582
0
    osec = sec;
2583
0
  }
2584
2585
0
      if (sec != NULL && discarded_section (sec))
2586
0
  RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2587
0
           rel, 1, relend, howto, 0, contents);
2588
2589
0
      if (bfd_link_relocatable (info))
2590
0
  continue;
2591
2592
0
      if (h != NULL
2593
0
    && (h->root.type == bfd_link_hash_defined
2594
0
        || h->root.type == bfd_link_hash_defweak)
2595
0
    && !BFINFDPIC_SYM_LOCAL (info, h))
2596
0
  {
2597
0
    osec = sec = NULL;
2598
0
    relocation = 0;
2599
0
  }
2600
2601
0
      switch (r_type)
2602
0
  {
2603
0
  case R_BFIN_PCREL24:
2604
0
  case R_BFIN_PCREL24_JUMP_L:
2605
0
  case R_BFIN_BYTE4_DATA:
2606
0
    if (! IS_FDPIC (output_bfd))
2607
0
      goto non_fdpic;
2608
    /* Fall through.  */
2609
2610
0
  case R_BFIN_GOT17M4:
2611
0
  case R_BFIN_GOTHI:
2612
0
  case R_BFIN_GOTLO:
2613
0
  case R_BFIN_FUNCDESC_GOT17M4:
2614
0
  case R_BFIN_FUNCDESC_GOTHI:
2615
0
  case R_BFIN_FUNCDESC_GOTLO:
2616
0
  case R_BFIN_GOTOFF17M4:
2617
0
  case R_BFIN_GOTOFFHI:
2618
0
  case R_BFIN_GOTOFFLO:
2619
0
  case R_BFIN_FUNCDESC_GOTOFF17M4:
2620
0
  case R_BFIN_FUNCDESC_GOTOFFHI:
2621
0
  case R_BFIN_FUNCDESC_GOTOFFLO:
2622
0
  case R_BFIN_FUNCDESC:
2623
0
  case R_BFIN_FUNCDESC_VALUE:
2624
0
    if ((input_section->flags & SEC_ALLOC) == 0)
2625
0
      break;
2626
2627
0
    if (h != NULL)
2628
0
      picrel = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info
2629
0
                   (info), input_bfd, h,
2630
0
                   orig_addend, INSERT);
2631
0
    else
2632
      /* In order to find the entry we created before, we must
2633
         use the original addend, not the one that may have been
2634
         modified by _bfd_elf_rela_local_sym().  */
2635
0
      picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
2636
0
                  (info), input_bfd, r_symndx,
2637
0
                  orig_addend, INSERT);
2638
0
    if (! picrel)
2639
0
      return false;
2640
2641
0
    if (!_bfinfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info,
2642
0
                   osec, sym,
2643
0
                   rel->r_addend))
2644
0
      {
2645
0
        _bfd_error_handler
2646
    /* xgettext:c-format */
2647
0
    (_("%pB: relocation at `%pA+%#" PRIx64 "' "
2648
0
       "references symbol `%s' with nonzero addend"),
2649
0
     input_bfd, input_section, (uint64_t) rel->r_offset, name);
2650
0
        return false;
2651
2652
0
      }
2653
2654
0
    break;
2655
2656
0
  default:
2657
0
  non_fdpic:
2658
0
    picrel = NULL;
2659
0
    if (h && ! BFINFDPIC_SYM_LOCAL (info, h)
2660
0
        && _bfd_elf_section_offset (output_bfd, info, input_section,
2661
0
            rel->r_offset) != (bfd_vma) -1)
2662
0
      {
2663
0
        info->callbacks->warning
2664
0
    (info, _("relocation references symbol not defined in the module"),
2665
0
     name, input_bfd, input_section, rel->r_offset);
2666
0
        return false;
2667
0
      }
2668
0
    break;
2669
0
  }
2670
2671
0
      switch (r_type)
2672
0
  {
2673
0
  case R_BFIN_PCREL24:
2674
0
  case R_BFIN_PCREL24_JUMP_L:
2675
0
    check_segment[0] = isec_segment;
2676
0
    if (! IS_FDPIC (output_bfd))
2677
0
      check_segment[1] = isec_segment;
2678
0
    else if (picrel->plt)
2679
0
      {
2680
0
        relocation = bfinfdpic_plt_section (info)->output_section->vma
2681
0
    + bfinfdpic_plt_section (info)->output_offset
2682
0
    + picrel->plt_entry;
2683
0
        check_segment[1] = plt_segment;
2684
0
      }
2685
    /* We don't want to warn on calls to undefined weak symbols,
2686
       as calls to them must be protected by non-NULL tests
2687
       anyway, and unprotected calls would invoke undefined
2688
       behavior.  */
2689
0
    else if (picrel->symndx == -1
2690
0
       && picrel->d.h->root.type == bfd_link_hash_undefweak)
2691
0
      check_segment[1] = check_segment[0];
2692
0
    else
2693
0
      check_segment[1] = sec
2694
0
        ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
2695
0
        : (unsigned)-1;
2696
0
    break;
2697
2698
0
  case R_BFIN_GOT17M4:
2699
0
  case R_BFIN_GOTHI:
2700
0
  case R_BFIN_GOTLO:
2701
0
    relocation = picrel->got_entry;
2702
0
    check_segment[0] = check_segment[1] = got_segment;
2703
0
    break;
2704
2705
0
  case R_BFIN_FUNCDESC_GOT17M4:
2706
0
  case R_BFIN_FUNCDESC_GOTHI:
2707
0
  case R_BFIN_FUNCDESC_GOTLO:
2708
0
    relocation = picrel->fdgot_entry;
2709
0
    check_segment[0] = check_segment[1] = got_segment;
2710
0
    break;
2711
2712
0
  case R_BFIN_GOTOFFHI:
2713
0
  case R_BFIN_GOTOFF17M4:
2714
0
  case R_BFIN_GOTOFFLO:
2715
0
    relocation -= bfinfdpic_got_section (info)->output_section->vma
2716
0
      + bfinfdpic_got_section (info)->output_offset
2717
0
      + bfinfdpic_got_initial_offset (info);
2718
0
    check_segment[0] = got_segment;
2719
0
    check_segment[1] = sec
2720
0
      ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
2721
0
      : (unsigned)-1;
2722
0
    break;
2723
2724
0
  case R_BFIN_FUNCDESC_GOTOFF17M4:
2725
0
  case R_BFIN_FUNCDESC_GOTOFFHI:
2726
0
  case R_BFIN_FUNCDESC_GOTOFFLO:
2727
0
    relocation = picrel->fd_entry;
2728
0
    check_segment[0] = check_segment[1] = got_segment;
2729
0
    break;
2730
2731
0
  case R_BFIN_FUNCDESC:
2732
0
    if ((input_section->flags & SEC_ALLOC) != 0)
2733
0
      {
2734
0
        int dynindx;
2735
0
        bfd_vma addend = rel->r_addend;
2736
2737
0
        if (! (h && h->root.type == bfd_link_hash_undefweak
2738
0
         && BFINFDPIC_SYM_LOCAL (info, h)))
2739
0
    {
2740
      /* If the symbol is dynamic and there may be dynamic
2741
         symbol resolution because we are or are linked with a
2742
         shared library, emit a FUNCDESC relocation such that
2743
         the dynamic linker will allocate the function
2744
         descriptor.  If the symbol needs a non-local function
2745
         descriptor but binds locally (e.g., its visibility is
2746
         protected, emit a dynamic relocation decayed to
2747
         section+offset.  */
2748
0
      if (h && ! BFINFDPIC_FUNCDESC_LOCAL (info, h)
2749
0
          && BFINFDPIC_SYM_LOCAL (info, h)
2750
0
          && !bfd_link_pde (info))
2751
0
        {
2752
0
          dynindx = elf_section_data (h->root.u.def.section
2753
0
              ->output_section)->dynindx;
2754
0
          addend += h->root.u.def.section->output_offset
2755
0
      + h->root.u.def.value;
2756
0
        }
2757
0
      else if (h && ! BFINFDPIC_FUNCDESC_LOCAL (info, h))
2758
0
        {
2759
0
          if (addend)
2760
0
      {
2761
0
        info->callbacks->warning
2762
0
          (info, _("R_BFIN_FUNCDESC references dynamic symbol with nonzero addend"),
2763
0
           name, input_bfd, input_section, rel->r_offset);
2764
0
        return false;
2765
0
      }
2766
0
          dynindx = h->dynindx;
2767
0
        }
2768
0
      else
2769
0
        {
2770
          /* Otherwise, we know we have a private function
2771
       descriptor, so reference it directly.  */
2772
0
          BFD_ASSERT (picrel->privfd);
2773
0
          r_type = R_BFIN_BYTE4_DATA;
2774
0
          dynindx = elf_section_data (bfinfdpic_got_section (info)
2775
0
              ->output_section)->dynindx;
2776
0
          addend = bfinfdpic_got_section (info)->output_offset
2777
0
      + bfinfdpic_got_initial_offset (info)
2778
0
      + picrel->fd_entry;
2779
0
        }
2780
2781
      /* If there is room for dynamic symbol resolution, emit
2782
         the dynamic relocation.  However, if we're linking an
2783
         executable at a fixed location, we won't have emitted a
2784
         dynamic symbol entry for the got section, so idx will
2785
         be zero, which means we can and should compute the
2786
         address of the private descriptor ourselves.  */
2787
0
      if (bfd_link_pde (info)
2788
0
          && (!h || BFINFDPIC_FUNCDESC_LOCAL (info, h)))
2789
0
        {
2790
0
          bfd_vma offset;
2791
2792
0
          addend += bfinfdpic_got_section (info)->output_section->vma;
2793
0
          if ((bfd_section_flags (input_section->output_section)
2794
0
         & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2795
0
      {
2796
0
        if (_bfinfdpic_osec_readonly_p (output_bfd,
2797
0
                input_section
2798
0
                ->output_section))
2799
0
          {
2800
0
            info->callbacks->warning
2801
0
        (info,
2802
0
         _("cannot emit fixups in read-only section"),
2803
0
         name, input_bfd, input_section, rel->r_offset);
2804
0
            return false;
2805
0
          }
2806
2807
0
        offset = _bfd_elf_section_offset
2808
0
          (output_bfd, info,
2809
0
           input_section, rel->r_offset);
2810
2811
0
        if (offset != (bfd_vma)-1)
2812
0
          _bfinfdpic_add_rofixup (output_bfd,
2813
0
                bfinfdpic_gotfixup_section
2814
0
                (info),
2815
0
                offset + input_section
2816
0
                ->output_section->vma
2817
0
                + input_section->output_offset,
2818
0
                picrel);
2819
0
      }
2820
0
        }
2821
0
      else if ((bfd_section_flags (input_section->output_section)
2822
0
          & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2823
0
        {
2824
0
          bfd_vma offset;
2825
2826
0
          if (_bfinfdpic_osec_readonly_p (output_bfd,
2827
0
                  input_section
2828
0
                  ->output_section))
2829
0
      {
2830
0
        info->callbacks->warning
2831
0
          (info,
2832
0
           _("cannot emit dynamic relocations in read-only section"),
2833
0
           name, input_bfd, input_section, rel->r_offset);
2834
0
        return false;
2835
0
      }
2836
0
          offset = _bfd_elf_section_offset (output_bfd, info,
2837
0
              input_section, rel->r_offset);
2838
2839
0
          if (offset != (bfd_vma)-1)
2840
0
      _bfinfdpic_add_dyn_reloc (output_bfd,
2841
0
              bfinfdpic_gotrel_section (info),
2842
0
              offset + input_section
2843
0
              ->output_section->vma
2844
0
              + input_section->output_offset,
2845
0
              r_type,
2846
0
              dynindx, addend, picrel);
2847
0
        }
2848
0
      else
2849
0
        addend += bfinfdpic_got_section (info)->output_section->vma;
2850
0
    }
2851
2852
        /* We want the addend in-place because dynamic
2853
     relocations are REL.  Setting relocation to it should
2854
     arrange for it to be installed.  */
2855
0
        relocation = addend - rel->r_addend;
2856
0
    }
2857
0
    check_segment[0] = check_segment[1] = got_segment;
2858
0
    break;
2859
2860
0
  case R_BFIN_BYTE4_DATA:
2861
0
    if (! IS_FDPIC (output_bfd))
2862
0
      {
2863
0
        check_segment[0] = check_segment[1] = -1;
2864
0
        break;
2865
0
      }
2866
    /* Fall through.  */
2867
0
  case R_BFIN_FUNCDESC_VALUE:
2868
0
    {
2869
0
      int dynindx;
2870
0
      bfd_vma addend = rel->r_addend;
2871
0
      bfd_vma offset;
2872
0
      offset = _bfd_elf_section_offset (output_bfd, info,
2873
0
                input_section, rel->r_offset);
2874
2875
      /* If the symbol is dynamic but binds locally, use
2876
         section+offset.  */
2877
0
      if (h && ! BFINFDPIC_SYM_LOCAL (info, h))
2878
0
        {
2879
0
    if (addend && r_type == R_BFIN_FUNCDESC_VALUE)
2880
0
      {
2881
0
        info->callbacks->warning
2882
0
          (info, _("R_BFIN_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
2883
0
           name, input_bfd, input_section, rel->r_offset);
2884
0
        return false;
2885
0
      }
2886
0
    dynindx = h->dynindx;
2887
0
        }
2888
0
      else
2889
0
        {
2890
0
    if (h)
2891
0
      addend += h->root.u.def.value;
2892
0
    else
2893
0
      addend += sym->st_value;
2894
0
    if (osec)
2895
0
      addend += osec->output_offset;
2896
0
    if (osec && osec->output_section
2897
0
        && ! bfd_is_abs_section (osec->output_section)
2898
0
        && ! bfd_is_und_section (osec->output_section))
2899
0
      dynindx = elf_section_data (osec->output_section)->dynindx;
2900
0
    else
2901
0
      dynindx = 0;
2902
0
        }
2903
2904
      /* If we're linking an executable at a fixed address, we
2905
         can omit the dynamic relocation as long as the symbol
2906
         is defined in the current link unit (which is implied
2907
         by its output section not being NULL).  */
2908
0
      if (bfd_link_pde (info)
2909
0
    && (!h || BFINFDPIC_SYM_LOCAL (info, h)))
2910
0
        {
2911
0
    if (osec)
2912
0
      addend += osec->output_section->vma;
2913
0
    if (IS_FDPIC (input_bfd)
2914
0
        && (bfd_section_flags (input_section->output_section)
2915
0
      & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2916
0
      {
2917
0
        if (_bfinfdpic_osec_readonly_p (output_bfd,
2918
0
               input_section
2919
0
               ->output_section))
2920
0
          {
2921
0
      info->callbacks->warning
2922
0
        (info,
2923
0
         _("cannot emit fixups in read-only section"),
2924
0
         name, input_bfd, input_section, rel->r_offset);
2925
0
      return false;
2926
0
          }
2927
0
        if (!h || h->root.type != bfd_link_hash_undefweak)
2928
0
          {
2929
0
      if (offset != (bfd_vma)-1)
2930
0
        {
2931
0
          _bfinfdpic_add_rofixup (output_bfd,
2932
0
                bfinfdpic_gotfixup_section
2933
0
                (info),
2934
0
                offset + input_section
2935
0
                ->output_section->vma
2936
0
                + input_section->output_offset,
2937
0
                picrel);
2938
2939
0
          if (r_type == R_BFIN_FUNCDESC_VALUE)
2940
0
            _bfinfdpic_add_rofixup
2941
0
        (output_bfd,
2942
0
         bfinfdpic_gotfixup_section (info),
2943
0
         offset + input_section->output_section->vma
2944
0
         + input_section->output_offset + 4, picrel);
2945
0
        }
2946
0
          }
2947
0
      }
2948
0
        }
2949
0
      else
2950
0
        {
2951
0
    if ((bfd_section_flags (input_section->output_section)
2952
0
         & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2953
0
      {
2954
0
        if (_bfinfdpic_osec_readonly_p (output_bfd,
2955
0
               input_section
2956
0
               ->output_section))
2957
0
          {
2958
0
      info->callbacks->warning
2959
0
        (info,
2960
0
         _("cannot emit dynamic relocations in read-only section"),
2961
0
         name, input_bfd, input_section, rel->r_offset);
2962
0
      return false;
2963
0
          }
2964
2965
0
        if (offset != (bfd_vma)-1)
2966
0
          _bfinfdpic_add_dyn_reloc (output_bfd,
2967
0
            bfinfdpic_gotrel_section (info),
2968
0
            offset
2969
0
            + input_section->output_section->vma
2970
0
            + input_section->output_offset,
2971
0
            r_type, dynindx, addend, picrel);
2972
0
      }
2973
0
    else if (osec)
2974
0
      addend += osec->output_section->vma;
2975
    /* We want the addend in-place because dynamic
2976
       relocations are REL.  Setting relocation to it
2977
       should arrange for it to be installed.  */
2978
0
    relocation = addend - rel->r_addend;
2979
0
        }
2980
2981
0
      if (r_type == R_BFIN_FUNCDESC_VALUE)
2982
0
        {
2983
    /* If we've omitted the dynamic relocation, just emit
2984
       the fixed addresses of the symbol and of the local
2985
       GOT base offset.  */
2986
0
    if (bfd_link_pde (info)
2987
0
        && (!h || BFINFDPIC_SYM_LOCAL (info, h)))
2988
0
      bfd_put_32 (output_bfd,
2989
0
            bfinfdpic_got_section (info)->output_section->vma
2990
0
            + bfinfdpic_got_section (info)->output_offset
2991
0
            + bfinfdpic_got_initial_offset (info),
2992
0
            contents + rel->r_offset + 4);
2993
0
    else
2994
      /* A function descriptor used for lazy or local
2995
         resolving is initialized such that its high word
2996
         contains the output section index in which the
2997
         PLT entries are located, and the low word
2998
         contains the offset of the lazy PLT entry entry
2999
         point into that section.  */
3000
0
      bfd_put_32 (output_bfd,
3001
0
            h && ! BFINFDPIC_SYM_LOCAL (info, h)
3002
0
            ? 0
3003
0
            : _bfinfdpic_osec_to_segment (output_bfd,
3004
0
                  sec
3005
0
                  ->output_section),
3006
0
            contents + rel->r_offset + 4);
3007
0
        }
3008
0
    }
3009
0
    check_segment[0] = check_segment[1] = got_segment;
3010
0
    break;
3011
3012
0
  default:
3013
0
    check_segment[0] = isec_segment;
3014
0
    check_segment[1] = sec
3015
0
      ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
3016
0
      : (unsigned)-1;
3017
0
    break;
3018
0
  }
3019
3020
0
      if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd))
3021
0
  {
3022
0
#if 1 /* If you take this out, remove the #error from fdpic-static-6.d
3023
   in the ld testsuite.  */
3024
    /* This helps catch problems in GCC while we can't do more
3025
       than static linking.  The idea is to test whether the
3026
       input file basename is crt0.o only once.  */
3027
0
    if (silence_segment_error == 1)
3028
0
      silence_segment_error =
3029
0
        (strlen (bfd_get_filename (input_bfd)) == 6
3030
0
         && filename_cmp (bfd_get_filename (input_bfd), "crt0.o") == 0)
3031
0
        || (strlen (bfd_get_filename (input_bfd)) > 6
3032
0
      && filename_cmp (bfd_get_filename (input_bfd)
3033
0
           + strlen (bfd_get_filename (input_bfd)) - 7,
3034
0
           "/crt0.o") == 0)
3035
0
        ? -1 : 0;
3036
0
#endif
3037
0
    if (!silence_segment_error
3038
        /* We don't want duplicate errors for undefined
3039
     symbols.  */
3040
0
        && !(picrel && picrel->symndx == -1
3041
0
       && picrel->d.h->root.type == bfd_link_hash_undefined))
3042
0
      info->callbacks->warning
3043
0
        (info,
3044
0
         bfd_link_pic (info)
3045
0
         ? _("relocations between different segments are not supported")
3046
0
         : _("warning: relocation references a different segment"),
3047
0
         name, input_bfd, input_section, rel->r_offset);
3048
0
    if (!silence_segment_error && bfd_link_pic (info))
3049
0
      return false;
3050
0
    elf_elfheader (output_bfd)->e_flags |= EF_BFIN_PIC;
3051
0
  }
3052
3053
0
      switch (r_type)
3054
0
  {
3055
0
  case R_BFIN_GOTOFFHI:
3056
    /* We need the addend to be applied before we shift the
3057
       value right.  */
3058
0
    relocation += rel->r_addend;
3059
    /* Fall through.  */
3060
0
  case R_BFIN_GOTHI:
3061
0
  case R_BFIN_FUNCDESC_GOTHI:
3062
0
  case R_BFIN_FUNCDESC_GOTOFFHI:
3063
0
    relocation >>= 16;
3064
    /* Fall through.  */
3065
3066
0
  case R_BFIN_GOTLO:
3067
0
  case R_BFIN_FUNCDESC_GOTLO:
3068
0
  case R_BFIN_GOTOFFLO:
3069
0
  case R_BFIN_FUNCDESC_GOTOFFLO:
3070
0
    relocation &= 0xffff;
3071
0
    break;
3072
3073
0
  default:
3074
0
    break;
3075
0
  }
3076
3077
0
      switch (r_type)
3078
0
  {
3079
0
  case R_BFIN_PCREL24:
3080
0
  case R_BFIN_PCREL24_JUMP_L:
3081
0
    if (! IS_FDPIC (output_bfd) || ! picrel->plt)
3082
0
      break;
3083
    /* Fall through.  */
3084
3085
    /* When referencing a GOT entry, a function descriptor or a
3086
       PLT, we don't want the addend to apply to the reference,
3087
       but rather to the referenced symbol.  The actual entry
3088
       will have already been created taking the addend into
3089
       account, so cancel it out here.  */
3090
0
  case R_BFIN_GOT17M4:
3091
0
  case R_BFIN_GOTHI:
3092
0
  case R_BFIN_GOTLO:
3093
0
  case R_BFIN_FUNCDESC_GOT17M4:
3094
0
  case R_BFIN_FUNCDESC_GOTHI:
3095
0
  case R_BFIN_FUNCDESC_GOTLO:
3096
0
  case R_BFIN_FUNCDESC_GOTOFF17M4:
3097
0
  case R_BFIN_FUNCDESC_GOTOFFHI:
3098
0
  case R_BFIN_FUNCDESC_GOTOFFLO:
3099
    /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF17M4
3100
       here, since we do want to apply the addend to the others.
3101
       Note that we've applied the addend to GOTOFFHI before we
3102
       shifted it right.  */
3103
0
  case R_BFIN_GOTOFFHI:
3104
0
    relocation -= rel->r_addend;
3105
0
    break;
3106
3107
0
  default:
3108
0
    break;
3109
0
  }
3110
3111
0
      r = bfin_final_link_relocate (rel, howto, input_bfd, input_section,
3112
0
            contents, rel->r_offset,
3113
0
            relocation, rel->r_addend);
3114
3115
0
      if (r != bfd_reloc_ok)
3116
0
  {
3117
0
    const char * msg = (const char *) NULL;
3118
3119
0
    switch (r)
3120
0
      {
3121
0
      case bfd_reloc_overflow:
3122
0
        (*info->callbacks->reloc_overflow)
3123
0
    (info, (h ? &h->root : NULL), name, howto->name,
3124
0
     (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3125
0
        break;
3126
3127
0
      case bfd_reloc_undefined:
3128
0
        (*info->callbacks->undefined_symbol)
3129
0
    (info, name, input_bfd, input_section, rel->r_offset, true);
3130
0
        break;
3131
3132
0
      case bfd_reloc_outofrange:
3133
0
        msg = _("internal error: out of range error");
3134
0
        break;
3135
3136
0
      case bfd_reloc_notsupported:
3137
0
        msg = _("internal error: unsupported relocation error");
3138
0
        break;
3139
3140
0
      case bfd_reloc_dangerous:
3141
0
        msg = _("internal error: dangerous relocation");
3142
0
        break;
3143
3144
0
      default:
3145
0
        msg = _("internal error: unknown error");
3146
0
        break;
3147
0
      }
3148
3149
0
    if (msg)
3150
0
      (*info->callbacks->warning) (info, msg, name, input_bfd,
3151
0
           input_section, rel->r_offset);
3152
0
  }
3153
0
    }
3154
3155
0
  return true;
3156
0
}
3157
3158
/* We need dynamic symbols for every section, since segments can
3159
   relocate independently.  */
3160
static bool
3161
_bfinfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
3162
            struct bfd_link_info *info ATTRIBUTE_UNUSED,
3163
            asection *p)
3164
0
{
3165
0
  switch (elf_section_data (p)->this_hdr.sh_type)
3166
0
    {
3167
0
    case SHT_PROGBITS:
3168
0
    case SHT_NOBITS:
3169
      /* If sh_type is yet undecided, assume it could be
3170
   SHT_PROGBITS/SHT_NOBITS.  */
3171
0
    case SHT_NULL:
3172
0
      return false;
3173
3174
      /* There shouldn't be section relative relocations
3175
   against any other section.  */
3176
0
    default:
3177
0
      return true;
3178
0
    }
3179
0
}
3180
3181
/* Create  a .got section, as well as its additional info field.  This
3182
   is almost entirely copied from
3183
   elflink.c:_bfd_elf_create_got_section().  */
3184
3185
static bool
3186
_bfin_create_got_section (bfd *abfd, struct bfd_link_info *info)
3187
0
{
3188
0
  flagword flags, pltflags;
3189
0
  asection *s;
3190
0
  struct elf_link_hash_entry *h;
3191
0
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3192
0
  int ptralign;
3193
3194
  /* This function may be called more than once.  */
3195
0
  s = elf_hash_table (info)->sgot;
3196
0
  if (s != NULL)
3197
0
    return true;
3198
3199
  /* Machine specific: although pointers are 32-bits wide, we want the
3200
     GOT to be aligned to a 64-bit boundary, such that function
3201
     descriptors in it can be accessed with 64-bit loads and
3202
     stores.  */
3203
0
  ptralign = 3;
3204
3205
0
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3206
0
     | SEC_LINKER_CREATED);
3207
0
  pltflags = flags;
3208
3209
0
  s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
3210
0
  elf_hash_table (info)->sgot = s;
3211
0
  if (s == NULL
3212
0
      || !bfd_set_section_alignment (s, ptralign))
3213
0
    return false;
3214
3215
0
  if (bed->want_got_sym)
3216
0
    {
3217
      /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
3218
   (or .got.plt) section.  We don't do this in the linker script
3219
   because we don't want to define the symbol if we are not creating
3220
   a global offset table.  */
3221
0
      h = _bfd_elf_define_linkage_sym (abfd, info, s, "__GLOBAL_OFFSET_TABLE_");
3222
0
      elf_hash_table (info)->hgot = h;
3223
0
      if (h == NULL)
3224
0
  return false;
3225
3226
      /* Machine-specific: we want the symbol for executables as
3227
   well.  */
3228
0
      if (! bfd_elf_link_record_dynamic_symbol (info, h))
3229
0
  return false;
3230
0
    }
3231
3232
  /* The first bit of the global offset table is the header.  */
3233
0
  s->size += bed->got_header_size;
3234
3235
  /* This is the machine-specific part.  Create and initialize section
3236
     data for the got.  */
3237
0
  if (IS_FDPIC (abfd))
3238
0
    {
3239
0
      bfinfdpic_relocs_info (info) = htab_try_create (1,
3240
0
                  bfinfdpic_relocs_info_hash,
3241
0
                  bfinfdpic_relocs_info_eq,
3242
0
                  (htab_del) NULL);
3243
0
      if (! bfinfdpic_relocs_info (info))
3244
0
  return false;
3245
3246
0
      s = bfd_make_section_anyway_with_flags (abfd, ".rel.got",
3247
0
                (flags | SEC_READONLY));
3248
0
      if (s == NULL
3249
0
    || !bfd_set_section_alignment (s, 2))
3250
0
  return false;
3251
3252
0
      bfinfdpic_gotrel_section (info) = s;
3253
3254
      /* Machine-specific.  */
3255
0
      s = bfd_make_section_anyway_with_flags (abfd, ".rofixup",
3256
0
                (flags | SEC_READONLY));
3257
0
      if (s == NULL
3258
0
    || !bfd_set_section_alignment (s, 2))
3259
0
  return false;
3260
3261
0
      bfinfdpic_gotfixup_section (info) = s;
3262
0
    }
3263
3264
0
  pltflags |= SEC_CODE;
3265
0
  if (bed->plt_not_loaded)
3266
0
    pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
3267
0
  if (bed->plt_readonly)
3268
0
    pltflags |= SEC_READONLY;
3269
3270
0
  s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
3271
0
  if (s == NULL
3272
0
      || !bfd_set_section_alignment (s, bed->plt_alignment))
3273
0
    return false;
3274
  /* Blackfin-specific: remember it.  */
3275
0
  bfinfdpic_plt_section (info) = s;
3276
3277
0
  if (bed->want_plt_sym)
3278
0
    {
3279
      /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3280
   .plt section.  */
3281
0
      struct bfd_link_hash_entry *bh = NULL;
3282
3283
0
      if (! (_bfd_generic_link_add_one_symbol
3284
0
       (info, abfd, "__PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
3285
0
        false, get_elf_backend_data (abfd)->collect, &bh)))
3286
0
  return false;
3287
0
      h = (struct elf_link_hash_entry *) bh;
3288
0
      h->def_regular = 1;
3289
0
      h->type = STT_OBJECT;
3290
3291
0
      if (! bfd_link_executable (info)
3292
0
    && ! bfd_elf_link_record_dynamic_symbol (info, h))
3293
0
  return false;
3294
0
    }
3295
3296
  /* Blackfin-specific: we want rel relocations for the plt.  */
3297
0
  s = bfd_make_section_anyway_with_flags (abfd, ".rel.plt",
3298
0
            flags | SEC_READONLY);
3299
0
  if (s == NULL
3300
0
      || !bfd_set_section_alignment (s, bed->s->log_file_align))
3301
0
    return false;
3302
  /* Blackfin-specific: remember it.  */
3303
0
  bfinfdpic_pltrel_section (info) = s;
3304
3305
0
  return true;
3306
0
}
3307
3308
/* Make sure the got and plt sections exist, and that our pointers in
3309
   the link hash table point to them.  */
3310
3311
static bool
3312
elf32_bfinfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3313
0
{
3314
  /* This is mostly copied from
3315
     elflink.c:_bfd_elf_create_dynamic_sections().  */
3316
0
  flagword flags;
3317
0
  asection *s;
3318
0
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3319
3320
0
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3321
0
     | SEC_LINKER_CREATED);
3322
3323
  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3324
     .rel[a].bss sections.  */
3325
3326
  /* Blackfin-specific: we want to create the GOT in the Blackfin way.  */
3327
0
  if (! _bfin_create_got_section (abfd, info))
3328
0
    return false;
3329
3330
  /* Blackfin-specific: make sure we created everything we wanted.  */
3331
0
  BFD_ASSERT (bfinfdpic_got_section (info) && bfinfdpic_gotrel_section (info)
3332
        /* && bfinfdpic_gotfixup_section (info) */
3333
0
        && bfinfdpic_plt_section (info)
3334
0
        && bfinfdpic_pltrel_section (info));
3335
3336
0
  if (bed->want_dynbss)
3337
0
    {
3338
      /* The .dynbss section is a place to put symbols which are defined
3339
   by dynamic objects, are referenced by regular objects, and are
3340
   not functions.  We must allocate space for them in the process
3341
   image and use a R_*_COPY reloc to tell the dynamic linker to
3342
   initialize them at run time.  The linker script puts the .dynbss
3343
   section into the .bss section of the final image.  */
3344
0
      s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
3345
0
                SEC_ALLOC | SEC_LINKER_CREATED);
3346
0
      if (s == NULL)
3347
0
  return false;
3348
3349
      /* The .rel[a].bss section holds copy relocs.  This section is not
3350
   normally needed.  We need to create it here, though, so that the
3351
   linker will map it to an output section.  We can't just create it
3352
   only if we need it, because we will not know whether we need it
3353
   until we have seen all the input files, and the first time the
3354
   main linker code calls BFD after examining all the input files
3355
   (size_dynamic_sections) the input sections have already been
3356
   mapped to the output sections.  If the section turns out not to
3357
   be needed, we can discard it later.  We will never need this
3358
   section when generating a shared object, since they do not use
3359
   copy relocs.  */
3360
0
      if (! bfd_link_pic (info))
3361
0
  {
3362
0
    s = bfd_make_section_anyway_with_flags (abfd,
3363
0
              ".rela.bss",
3364
0
              flags | SEC_READONLY);
3365
0
    if (s == NULL
3366
0
        || !bfd_set_section_alignment (s, bed->s->log_file_align))
3367
0
      return false;
3368
0
  }
3369
0
    }
3370
3371
0
  return true;
3372
0
}
3373
3374
/* Compute the total GOT size required by each symbol in each range.
3375
   Symbols may require up to 4 words in the GOT: an entry pointing to
3376
   the symbol, an entry pointing to its function descriptor, and a
3377
   private function descriptors taking two words.  */
3378
3379
static void
3380
_bfinfdpic_count_nontls_entries (struct bfinfdpic_relocs_info *entry,
3381
         struct _bfinfdpic_dynamic_got_info *dinfo)
3382
0
{
3383
  /* Allocate space for a GOT entry pointing to the symbol.  */
3384
0
  if (entry->got17m4)
3385
0
    dinfo->got17m4 += 4;
3386
0
  else if (entry->gothilo)
3387
0
    dinfo->gothilo += 4;
3388
0
  else
3389
0
    entry->relocs32--;
3390
0
  entry->relocs32++;
3391
3392
  /* Allocate space for a GOT entry pointing to the function
3393
     descriptor.  */
3394
0
  if (entry->fdgot17m4)
3395
0
    dinfo->got17m4 += 4;
3396
0
  else if (entry->fdgothilo)
3397
0
    dinfo->gothilo += 4;
3398
0
  else
3399
0
    entry->relocsfd--;
3400
0
  entry->relocsfd++;
3401
3402
  /* Decide whether we need a PLT entry, a function descriptor in the
3403
     GOT, and a lazy PLT entry for this symbol.  */
3404
0
  entry->plt = entry->call
3405
0
    && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3406
0
    && elf_hash_table (dinfo->info)->dynamic_sections_created;
3407
0
  entry->privfd = entry->plt
3408
0
    || entry->fdgoff17m4 || entry->fdgoffhilo
3409
0
    || ((entry->fd || entry->fdgot17m4 || entry->fdgothilo)
3410
0
  && (entry->symndx != -1
3411
0
      || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
3412
0
  entry->lazyplt = entry->privfd
3413
0
    && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3414
0
    && ! (dinfo->info->flags & DF_BIND_NOW)
3415
0
    && elf_hash_table (dinfo->info)->dynamic_sections_created;
3416
3417
  /* Allocate space for a function descriptor.  */
3418
0
  if (entry->fdgoff17m4)
3419
0
    dinfo->fd17m4 += 8;
3420
0
  else if (entry->privfd && entry->plt)
3421
0
    dinfo->fdplt += 8;
3422
0
  else if (entry->privfd)
3423
0
    dinfo->fdhilo += 8;
3424
0
  else
3425
0
    entry->relocsfdv--;
3426
0
  entry->relocsfdv++;
3427
3428
0
  if (entry->lazyplt)
3429
0
    dinfo->lzplt += LZPLT_NORMAL_SIZE;
3430
0
}
3431
3432
/* Compute the number of dynamic relocations and fixups that a symbol
3433
   requires, and add (or subtract) from the grand and per-symbol
3434
   totals.  */
3435
3436
static void
3437
_bfinfdpic_count_relocs_fixups (struct bfinfdpic_relocs_info *entry,
3438
        struct _bfinfdpic_dynamic_got_info *dinfo,
3439
        bool subtract)
3440
0
{
3441
0
  bfd_vma relocs = 0, fixups = 0;
3442
3443
0
  if (!bfd_link_pde (dinfo->info))
3444
0
    relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv;
3445
0
  else
3446
0
    {
3447
0
      if (entry->symndx != -1 || BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
3448
0
  {
3449
0
    if (entry->symndx != -1
3450
0
        || entry->d.h->root.type != bfd_link_hash_undefweak)
3451
0
      fixups += entry->relocs32 + 2 * entry->relocsfdv;
3452
0
  }
3453
0
      else
3454
0
  relocs += entry->relocs32 + entry->relocsfdv;
3455
3456
0
      if (entry->symndx != -1
3457
0
    || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
3458
0
  {
3459
0
    if (entry->symndx != -1
3460
0
        || entry->d.h->root.type != bfd_link_hash_undefweak)
3461
0
      fixups += entry->relocsfd;
3462
0
  }
3463
0
      else
3464
0
  relocs += entry->relocsfd;
3465
0
    }
3466
3467
0
  if (subtract)
3468
0
    {
3469
0
      relocs = - relocs;
3470
0
      fixups = - fixups;
3471
0
    }
3472
3473
0
  entry->dynrelocs += relocs;
3474
0
  entry->fixups += fixups;
3475
0
  dinfo->relocs += relocs;
3476
0
  dinfo->fixups += fixups;
3477
0
}
3478
3479
/* Compute the total GOT and PLT size required by each symbol in each range. *
3480
   Symbols may require up to 4 words in the GOT: an entry pointing to
3481
   the symbol, an entry pointing to its function descriptor, and a
3482
   private function descriptors taking two words.  */
3483
3484
static int
3485
_bfinfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
3486
0
{
3487
0
  struct bfinfdpic_relocs_info *entry = *entryp;
3488
0
  struct _bfinfdpic_dynamic_got_info *dinfo = dinfo_;
3489
3490
0
  _bfinfdpic_count_nontls_entries (entry, dinfo);
3491
3492
0
  _bfinfdpic_count_relocs_fixups (entry, dinfo, false);
3493
3494
0
  return 1;
3495
0
}
3496
3497
/* This structure is used to assign offsets to got entries, function
3498
   descriptors, plt entries and lazy plt entries.  */
3499
3500
struct _bfinfdpic_dynamic_got_plt_info
3501
{
3502
  /* Summary information collected with _bfinfdpic_count_got_plt_entries.  */
3503
  struct _bfinfdpic_dynamic_got_info g;
3504
3505
  /* For each addressable range, we record a MAX (positive) and MIN
3506
     (negative) value.  CUR is used to assign got entries, and it's
3507
     incremented from an initial positive value to MAX, then from MIN
3508
     to FDCUR (unless FDCUR wraps around first).  FDCUR is used to
3509
     assign function descriptors, and it's decreased from an initial
3510
     non-positive value to MIN, then from MAX down to CUR (unless CUR
3511
     wraps around first).  All of MIN, MAX, CUR and FDCUR always point
3512
     to even words.  ODD, if non-zero, indicates an odd word to be
3513
     used for the next got entry, otherwise CUR is used and
3514
     incremented by a pair of words, wrapping around when it reaches
3515
     MAX.  FDCUR is decremented (and wrapped) before the next function
3516
     descriptor is chosen.  FDPLT indicates the number of remaining
3517
     slots that can be used for function descriptors used only by PLT
3518
     entries.  */
3519
  struct _bfinfdpic_dynamic_got_alloc_data
3520
  {
3521
    bfd_signed_vma max, cur, odd, fdcur, min;
3522
    bfd_vma fdplt;
3523
  } got17m4, gothilo;
3524
};
3525
3526
/* Determine the positive and negative ranges to be used by each
3527
   offset range in the GOT.  FDCUR and CUR, that must be aligned to a
3528
   double-word boundary, are the minimum (negative) and maximum
3529
   (positive) GOT offsets already used by previous ranges, except for
3530
   an ODD entry that may have been left behind.  GOT and FD indicate
3531
   the size of GOT entries and function descriptors that must be
3532
   placed within the range from -WRAP to WRAP.  If there's room left,
3533
   up to FDPLT bytes should be reserved for additional function
3534
   descriptors.  */
3535
3536
inline static bfd_signed_vma
3537
_bfinfdpic_compute_got_alloc_data (struct _bfinfdpic_dynamic_got_alloc_data *gad,
3538
           bfd_signed_vma fdcur,
3539
           bfd_signed_vma odd,
3540
           bfd_signed_vma cur,
3541
           bfd_vma got,
3542
           bfd_vma fd,
3543
           bfd_vma fdplt,
3544
           bfd_vma wrap)
3545
0
{
3546
0
  bfd_signed_vma wrapmin = -wrap;
3547
3548
  /* Start at the given initial points.  */
3549
0
  gad->fdcur = fdcur;
3550
0
  gad->cur = cur;
3551
3552
  /* If we had an incoming odd word and we have any got entries that
3553
     are going to use it, consume it, otherwise leave gad->odd at
3554
     zero.  We might force gad->odd to zero and return the incoming
3555
     odd such that it is used by the next range, but then GOT entries
3556
     might appear to be out of order and we wouldn't be able to
3557
     shorten the GOT by one word if it turns out to end with an
3558
     unpaired GOT entry.  */
3559
0
  if (odd && got)
3560
0
    {
3561
0
      gad->odd = odd;
3562
0
      got -= 4;
3563
0
      odd = 0;
3564
0
    }
3565
0
  else
3566
0
    gad->odd = 0;
3567
3568
  /* If we're left with an unpaired GOT entry, compute its location
3569
     such that we can return it.  Otherwise, if got doesn't require an
3570
     odd number of words here, either odd was already zero in the
3571
     block above, or it was set to zero because got was non-zero, or
3572
     got was already zero.  In the latter case, we want the value of
3573
     odd to carry over to the return statement, so we don't want to
3574
     reset odd unless the condition below is true.  */
3575
0
  if (got & 4)
3576
0
    {
3577
0
      odd = cur + got;
3578
0
      got += 4;
3579
0
    }
3580
3581
  /* Compute the tentative boundaries of this range.  */
3582
0
  gad->max = cur + got;
3583
0
  gad->min = fdcur - fd;
3584
0
  gad->fdplt = 0;
3585
3586
  /* If function descriptors took too much space, wrap some of them
3587
     around.  */
3588
0
  if (gad->min < wrapmin)
3589
0
    {
3590
0
      gad->max += wrapmin - gad->min;
3591
0
      gad->min = wrapmin;
3592
0
    }
3593
  /* If there is space left and we have function descriptors
3594
     referenced in PLT entries that could take advantage of shorter
3595
     offsets, place them here.  */
3596
0
  else if (fdplt && gad->min > wrapmin)
3597
0
    {
3598
0
      bfd_vma fds;
3599
0
      if ((bfd_vma) (gad->min - wrapmin) < fdplt)
3600
0
  fds = gad->min - wrapmin;
3601
0
      else
3602
0
  fds = fdplt;
3603
3604
0
      fdplt -= fds;
3605
0
      gad->min -= fds;
3606
0
      gad->fdplt += fds;
3607
0
    }
3608
3609
  /* If GOT entries took too much space, wrap some of them around.
3610
     This may well cause gad->min to become lower than wrapmin.  This
3611
     will cause a relocation overflow later on, so we don't have to
3612
     report it here . */
3613
0
  if ((bfd_vma) gad->max > wrap)
3614
0
    {
3615
0
      gad->min -= gad->max - wrap;
3616
0
      gad->max = wrap;
3617
0
    }
3618
  /* If there is more space left, try to place some more function
3619
     descriptors for PLT entries.  */
3620
0
  else if (fdplt && (bfd_vma) gad->max < wrap)
3621
0
    {
3622
0
      bfd_vma fds;
3623
0
      if ((bfd_vma) (wrap - gad->max) < fdplt)
3624
0
  fds = wrap - gad->max;
3625
0
      else
3626
0
  fds = fdplt;
3627
3628
0
      fdplt -= fds;
3629
0
      gad->max += fds;
3630
0
      gad->fdplt += fds;
3631
0
    }
3632
3633
  /* If odd was initially computed as an offset past the wrap point,
3634
     wrap it around.  */
3635
0
  if (odd > gad->max)
3636
0
    odd = gad->min + odd - gad->max;
3637
3638
  /* _bfinfdpic_get_got_entry() below will always wrap gad->cur if needed
3639
     before returning, so do it here too.  This guarantees that,
3640
     should cur and fdcur meet at the wrap point, they'll both be
3641
     equal to min.  */
3642
0
  if (gad->cur == gad->max)
3643
0
    gad->cur = gad->min;
3644
3645
0
  return odd;
3646
0
}
3647
3648
/* Compute the location of the next GOT entry, given the allocation
3649
   data for a range.  */
3650
3651
inline static bfd_signed_vma
3652
_bfinfdpic_get_got_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3653
0
{
3654
0
  bfd_signed_vma ret;
3655
3656
0
  if (gad->odd)
3657
0
    {
3658
      /* If there was an odd word left behind, use it.  */
3659
0
      ret = gad->odd;
3660
0
      gad->odd = 0;
3661
0
    }
3662
0
  else
3663
0
    {
3664
      /* Otherwise, use the word pointed to by cur, reserve the next
3665
   as an odd word, and skip to the next pair of words, possibly
3666
   wrapping around.  */
3667
0
      ret = gad->cur;
3668
0
      gad->odd = gad->cur + 4;
3669
0
      gad->cur += 8;
3670
0
      if (gad->cur == gad->max)
3671
0
  gad->cur = gad->min;
3672
0
    }
3673
3674
0
  return ret;
3675
0
}
3676
3677
/* Compute the location of the next function descriptor entry in the
3678
   GOT, given the allocation data for a range.  */
3679
3680
inline static bfd_signed_vma
3681
_bfinfdpic_get_fd_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3682
0
{
3683
  /* If we're at the bottom, wrap around, and only then allocate the
3684
     next pair of words.  */
3685
0
  if (gad->fdcur == gad->min)
3686
0
    gad->fdcur = gad->max;
3687
0
  return gad->fdcur -= 8;
3688
0
}
3689
3690
/* Assign GOT offsets for every GOT entry and function descriptor.
3691
   Doing everything in a single pass is tricky.  */
3692
3693
static int
3694
_bfinfdpic_assign_got_entries (void **entryp, void *info_)
3695
0
{
3696
0
  struct bfinfdpic_relocs_info *entry = *entryp;
3697
0
  struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3698
3699
0
  if (entry->got17m4)
3700
0
    entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3701
0
  else if (entry->gothilo)
3702
0
    entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3703
3704
0
  if (entry->fdgot17m4)
3705
0
    entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3706
0
  else if (entry->fdgothilo)
3707
0
    entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3708
3709
0
  if (entry->fdgoff17m4)
3710
0
    entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3711
0
  else if (entry->plt && dinfo->got17m4.fdplt)
3712
0
    {
3713
0
      dinfo->got17m4.fdplt -= 8;
3714
0
      entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3715
0
    }
3716
0
  else if (entry->plt)
3717
0
    {
3718
0
      dinfo->gothilo.fdplt -= 8;
3719
0
      entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3720
0
    }
3721
0
  else if (entry->privfd)
3722
0
    entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3723
3724
0
  return 1;
3725
0
}
3726
3727
/* Assign GOT offsets to private function descriptors used by PLT
3728
   entries (or referenced by 32-bit offsets), as well as PLT entries
3729
   and lazy PLT entries.  */
3730
3731
static int
3732
_bfinfdpic_assign_plt_entries (void **entryp, void *info_)
3733
0
{
3734
0
  struct bfinfdpic_relocs_info *entry = *entryp;
3735
0
  struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3736
3737
  /* If this symbol requires a local function descriptor, allocate
3738
     one.  */
3739
0
  if (entry->privfd && entry->fd_entry == 0)
3740
0
    {
3741
0
      if (dinfo->got17m4.fdplt)
3742
0
  {
3743
0
    entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3744
0
    dinfo->got17m4.fdplt -= 8;
3745
0
  }
3746
0
      else
3747
0
  {
3748
0
    BFD_ASSERT (dinfo->gothilo.fdplt);
3749
0
    entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3750
0
    dinfo->gothilo.fdplt -= 8;
3751
0
  }
3752
0
    }
3753
3754
0
  if (entry->plt)
3755
0
    {
3756
0
      int size;
3757
3758
      /* We use the section's raw size to mark the location of the
3759
   next PLT entry.  */
3760
0
      entry->plt_entry = bfinfdpic_plt_section (dinfo->g.info)->size;
3761
3762
      /* Figure out the length of this PLT entry based on the
3763
   addressing mode we need to reach the function descriptor.  */
3764
0
      BFD_ASSERT (entry->fd_entry);
3765
0
      if (entry->fd_entry >= -(1 << (18 - 1))
3766
0
    && entry->fd_entry + 4 < (1 << (18 - 1)))
3767
0
  size = 10;
3768
0
      else
3769
0
  size = 16;
3770
3771
0
      bfinfdpic_plt_section (dinfo->g.info)->size += size;
3772
0
    }
3773
3774
0
  if (entry->lazyplt)
3775
0
    {
3776
0
      entry->lzplt_entry = dinfo->g.lzplt;
3777
0
      dinfo->g.lzplt += LZPLT_NORMAL_SIZE;
3778
      /* If this entry is the one that gets the resolver stub, account
3779
   for the additional instruction.  */
3780
0
      if (entry->lzplt_entry % BFINFDPIC_LZPLT_BLOCK_SIZE
3781
0
    == BFINFDPIC_LZPLT_RESOLV_LOC)
3782
0
  dinfo->g.lzplt += LZPLT_RESOLVER_EXTRA;
3783
0
    }
3784
3785
0
  return 1;
3786
0
}
3787
3788
/* Cancel out any effects of calling _bfinfdpic_assign_got_entries and
3789
   _bfinfdpic_assign_plt_entries.  */
3790
3791
static int
3792
_bfinfdpic_reset_got_plt_entries (void **entryp, void *ignore ATTRIBUTE_UNUSED)
3793
0
{
3794
0
  struct bfinfdpic_relocs_info *entry = *entryp;
3795
3796
0
  entry->got_entry = 0;
3797
0
  entry->fdgot_entry = 0;
3798
0
  entry->fd_entry = 0;
3799
0
  entry->plt_entry = (bfd_vma)-1;
3800
0
  entry->lzplt_entry = (bfd_vma)-1;
3801
3802
0
  return 1;
3803
0
}
3804
3805
/* Follow indirect and warning hash entries so that each got entry
3806
   points to the final symbol definition.  P must point to a pointer
3807
   to the hash table we're traversing.  Since this traversal may
3808
   modify the hash table, we set this pointer to NULL to indicate
3809
   we've made a potentially-destructive change to the hash table, so
3810
   the traversal must be restarted.  */
3811
static int
3812
_bfinfdpic_resolve_final_relocs_info (void **entryp, void *p)
3813
0
{
3814
0
  struct bfinfdpic_relocs_info *entry = *entryp;
3815
0
  htab_t *htab = p;
3816
3817
0
  if (entry->symndx == -1)
3818
0
    {
3819
0
      struct elf_link_hash_entry *h = entry->d.h;
3820
0
      struct bfinfdpic_relocs_info *oentry;
3821
3822
0
      while (h->root.type == bfd_link_hash_indirect
3823
0
       || h->root.type == bfd_link_hash_warning)
3824
0
  h = (struct elf_link_hash_entry *)h->root.u.i.link;
3825
3826
0
      if (entry->d.h == h)
3827
0
  return 1;
3828
3829
0
      oentry = bfinfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
3830
0
            NO_INSERT);
3831
3832
0
      if (oentry)
3833
0
  {
3834
    /* Merge the two entries.  */
3835
0
    bfinfdpic_pic_merge_early_relocs_info (oentry, entry);
3836
0
    htab_clear_slot (*htab, entryp);
3837
0
    return 1;
3838
0
  }
3839
3840
0
      entry->d.h = h;
3841
3842
      /* If we can't find this entry with the new bfd hash, re-insert
3843
   it, and get the traversal restarted.  */
3844
0
      if (! htab_find (*htab, entry))
3845
0
  {
3846
0
    htab_clear_slot (*htab, entryp);
3847
0
    entryp = htab_find_slot (*htab, entry, INSERT);
3848
0
    if (! *entryp)
3849
0
      *entryp = entry;
3850
    /* Abort the traversal, since the whole table may have
3851
       moved, and leave it up to the parent to restart the
3852
       process.  */
3853
0
    *(htab_t *)p = NULL;
3854
0
    return 0;
3855
0
  }
3856
0
    }
3857
3858
0
  return 1;
3859
0
}
3860
3861
/* Compute the total size of the GOT, the PLT, the dynamic relocations
3862
   section and the rofixup section.  Assign locations for GOT and PLT
3863
   entries.  */
3864
3865
static bool
3866
_bfinfdpic_size_got_plt (bfd *output_bfd,
3867
       struct _bfinfdpic_dynamic_got_plt_info *gpinfop)
3868
0
{
3869
0
  bfd_signed_vma odd;
3870
0
  bfd_vma limit;
3871
0
  struct bfd_link_info *info = gpinfop->g.info;
3872
0
  bfd *dynobj = elf_hash_table (info)->dynobj;
3873
3874
0
  memcpy (bfinfdpic_dynamic_got_plt_info (info), &gpinfop->g,
3875
0
    sizeof (gpinfop->g));
3876
3877
0
  odd = 12;
3878
  /* Compute the total size taken by entries in the 18-bit range,
3879
     to tell how many PLT function descriptors we can bring into it
3880
     without causing it to overflow.  */
3881
0
  limit = odd + gpinfop->g.got17m4 + gpinfop->g.fd17m4;
3882
0
  if (limit < (bfd_vma)1 << 18)
3883
0
    limit = ((bfd_vma)1 << 18) - limit;
3884
0
  else
3885
0
    limit = 0;
3886
0
  if (gpinfop->g.fdplt < limit)
3887
0
    limit = gpinfop->g.fdplt;
3888
3889
  /* Determine the ranges of GOT offsets that we can use for each
3890
     range of addressing modes.  */
3891
0
  odd = _bfinfdpic_compute_got_alloc_data (&gpinfop->got17m4,
3892
0
            0,
3893
0
            odd,
3894
0
            16,
3895
0
            gpinfop->g.got17m4,
3896
0
            gpinfop->g.fd17m4,
3897
0
            limit,
3898
0
            (bfd_vma)1 << (18-1));
3899
0
  odd = _bfinfdpic_compute_got_alloc_data (&gpinfop->gothilo,
3900
0
            gpinfop->got17m4.min,
3901
0
            odd,
3902
0
            gpinfop->got17m4.max,
3903
0
            gpinfop->g.gothilo,
3904
0
            gpinfop->g.fdhilo,
3905
0
            gpinfop->g.fdplt - gpinfop->got17m4.fdplt,
3906
0
            (bfd_vma)1 << (32-1));
3907
3908
  /* Now assign (most) GOT offsets.  */
3909
0
  htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_got_entries,
3910
0
     gpinfop);
3911
3912
0
  bfinfdpic_got_section (info)->size = gpinfop->gothilo.max
3913
0
    - gpinfop->gothilo.min
3914
    /* If an odd word is the last word of the GOT, we don't need this
3915
       word to be part of the GOT.  */
3916
0
    - (odd + 4 == gpinfop->gothilo.max ? 4 : 0);
3917
0
  if (bfinfdpic_got_section (info)->size == 0)
3918
0
    bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
3919
0
  else if (bfinfdpic_got_section (info)->size == 12
3920
0
     && ! elf_hash_table (info)->dynamic_sections_created)
3921
0
    {
3922
0
      bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
3923
0
      bfinfdpic_got_section (info)->size = 0;
3924
0
    }
3925
0
  else
3926
0
    {
3927
0
      bfinfdpic_got_section (info)->contents =
3928
0
  (bfd_byte *) bfd_zalloc (dynobj,
3929
0
         bfinfdpic_got_section (info)->size);
3930
0
      if (bfinfdpic_got_section (info)->contents == NULL)
3931
0
  return false;
3932
0
    }
3933
3934
0
  if (elf_hash_table (info)->dynamic_sections_created)
3935
    /* Subtract the number of lzplt entries, since those will generate
3936
       relocations in the pltrel section.  */
3937
0
    bfinfdpic_gotrel_section (info)->size =
3938
0
      (gpinfop->g.relocs - gpinfop->g.lzplt / LZPLT_NORMAL_SIZE)
3939
0
      * get_elf_backend_data (output_bfd)->s->sizeof_rel;
3940
0
  else
3941
0
    BFD_ASSERT (gpinfop->g.relocs == 0);
3942
0
  if (bfinfdpic_gotrel_section (info)->size == 0)
3943
0
    bfinfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
3944
0
  else
3945
0
    {
3946
0
      bfinfdpic_gotrel_section (info)->contents =
3947
0
  (bfd_byte *) bfd_zalloc (dynobj,
3948
0
         bfinfdpic_gotrel_section (info)->size);
3949
0
      if (bfinfdpic_gotrel_section (info)->contents == NULL)
3950
0
  return false;
3951
0
    }
3952
3953
0
  bfinfdpic_gotfixup_section (info)->size = (gpinfop->g.fixups + 1) * 4;
3954
0
  if (bfinfdpic_gotfixup_section (info)->size == 0)
3955
0
    bfinfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
3956
0
  else
3957
0
    {
3958
0
      bfinfdpic_gotfixup_section (info)->contents =
3959
0
  (bfd_byte *) bfd_zalloc (dynobj,
3960
0
         bfinfdpic_gotfixup_section (info)->size);
3961
0
      if (bfinfdpic_gotfixup_section (info)->contents == NULL)
3962
0
  return false;
3963
0
    }
3964
3965
0
  if (elf_hash_table (info)->dynamic_sections_created)
3966
0
    bfinfdpic_pltrel_section (info)->size =
3967
0
      gpinfop->g.lzplt / LZPLT_NORMAL_SIZE * get_elf_backend_data (output_bfd)->s->sizeof_rel;
3968
0
  if (bfinfdpic_pltrel_section (info)->size == 0)
3969
0
    bfinfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
3970
0
  else
3971
0
    {
3972
0
      bfinfdpic_pltrel_section (info)->contents =
3973
0
  (bfd_byte *) bfd_zalloc (dynobj,
3974
0
         bfinfdpic_pltrel_section (info)->size);
3975
0
      if (bfinfdpic_pltrel_section (info)->contents == NULL)
3976
0
  return false;
3977
0
    }
3978
3979
  /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
3980
     such that there's room for the additional instruction needed to
3981
     call the resolver.  Since _bfinfdpic_assign_got_entries didn't
3982
     account for them, our block size is 4 bytes smaller than the real
3983
     block size.  */
3984
0
  if (elf_hash_table (info)->dynamic_sections_created)
3985
0
    {
3986
0
      bfinfdpic_plt_section (info)->size = gpinfop->g.lzplt
3987
0
  + ((gpinfop->g.lzplt + (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) - LZPLT_NORMAL_SIZE)
3988
0
     / (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) * LZPLT_RESOLVER_EXTRA);
3989
0
    }
3990
3991
  /* Reset it, such that _bfinfdpic_assign_plt_entries() can use it to
3992
     actually assign lazy PLT entries addresses.  */
3993
0
  gpinfop->g.lzplt = 0;
3994
3995
  /* Save information that we're going to need to generate GOT and PLT
3996
     entries.  */
3997
0
  bfinfdpic_got_initial_offset (info) = -gpinfop->gothilo.min;
3998
3999
0
  if (get_elf_backend_data (output_bfd)->want_got_sym)
4000
0
    elf_hash_table (info)->hgot->root.u.def.value
4001
0
      = bfinfdpic_got_initial_offset (info);
4002
4003
0
  if (elf_hash_table (info)->dynamic_sections_created)
4004
0
    bfinfdpic_plt_initial_offset (info) =
4005
0
      bfinfdpic_plt_section (info)->size;
4006
4007
0
  htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_plt_entries,
4008
0
     gpinfop);
4009
4010
  /* Allocate the PLT section contents only after
4011
     _bfinfdpic_assign_plt_entries has a chance to add the size of the
4012
     non-lazy PLT entries.  */
4013
0
  if (bfinfdpic_plt_section (info)->size == 0)
4014
0
    bfinfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
4015
0
  else
4016
0
    {
4017
0
      bfinfdpic_plt_section (info)->contents =
4018
0
  (bfd_byte *) bfd_zalloc (dynobj,
4019
0
         bfinfdpic_plt_section (info)->size);
4020
0
      if (bfinfdpic_plt_section (info)->contents == NULL)
4021
0
  return false;
4022
0
    }
4023
4024
0
  return true;
4025
0
}
4026
4027
/* Set the sizes of the dynamic sections.  */
4028
4029
static bool
4030
elf32_bfinfdpic_late_size_sections (bfd *output_bfd,
4031
            struct bfd_link_info *info)
4032
0
{
4033
0
  struct elf_link_hash_table *htab;
4034
0
  bfd *dynobj;
4035
0
  asection *s;
4036
0
  struct _bfinfdpic_dynamic_got_plt_info gpinfo;
4037
4038
0
  htab = elf_hash_table (info);
4039
0
  dynobj = htab->dynobj;
4040
0
  if (dynobj == NULL)
4041
0
    return true;
4042
4043
0
  if (htab->dynamic_sections_created)
4044
0
    {
4045
      /* Set the contents of the .interp section to the interpreter.  */
4046
0
      if (bfd_link_executable (info) && !info->nointerp)
4047
0
  {
4048
0
    s = bfd_get_linker_section (dynobj, ".interp");
4049
0
    BFD_ASSERT (s != NULL);
4050
0
    s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4051
0
    s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
4052
0
  }
4053
0
    }
4054
4055
0
  memset (&gpinfo, 0, sizeof (gpinfo));
4056
0
  gpinfo.g.info = info;
4057
4058
0
  for (;;)
4059
0
    {
4060
0
      htab_t relocs = bfinfdpic_relocs_info (info);
4061
4062
0
      htab_traverse (relocs, _bfinfdpic_resolve_final_relocs_info, &relocs);
4063
4064
0
      if (relocs == bfinfdpic_relocs_info (info))
4065
0
  break;
4066
0
    }
4067
4068
0
  htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_count_got_plt_entries,
4069
0
     &gpinfo.g);
4070
4071
  /* Allocate space to save the summary information, we're going to
4072
     use it if we're doing relaxations.  */
4073
0
  bfinfdpic_dynamic_got_plt_info (info) = bfd_alloc (dynobj, sizeof (gpinfo.g));
4074
4075
0
  if (!_bfinfdpic_size_got_plt (output_bfd, &gpinfo))
4076
0
      return false;
4077
4078
0
  s = bfd_get_linker_section (dynobj, ".dynbss");
4079
0
  if (s && s->size == 0)
4080
0
    s->flags |= SEC_EXCLUDE;
4081
4082
0
  s = bfd_get_linker_section (dynobj, ".rela.bss");
4083
0
  if (s && s->size == 0)
4084
0
    s->flags |= SEC_EXCLUDE;
4085
4086
0
  return _bfd_elf_add_dynamic_tags (output_bfd, info, true);
4087
0
}
4088
4089
static bool
4090
elf32_bfinfdpic_early_size_sections (bfd *output_bfd,
4091
             struct bfd_link_info *info)
4092
0
{
4093
0
  if (!bfd_link_relocatable (info)
4094
0
      && !bfd_elf_stack_segment_size (output_bfd, info,
4095
0
              "__stacksize", DEFAULT_STACK_SIZE))
4096
0
    return false;
4097
4098
0
  return true;
4099
0
}
4100
4101
/* Check whether any of the relocations was optimized away, and
4102
   subtract it from the relocation or fixup count.  */
4103
static bool
4104
_bfinfdpic_check_discarded_relocs (bfd *abfd, asection *sec,
4105
           struct bfd_link_info *info,
4106
           bool *changed)
4107
0
{
4108
0
  Elf_Internal_Shdr *symtab_hdr;
4109
0
  struct elf_link_hash_entry **sym_hashes;
4110
0
  Elf_Internal_Rela *rel, *erel;
4111
4112
0
  if ((sec->flags & SEC_RELOC) == 0
4113
0
      || sec->reloc_count == 0)
4114
0
    return true;
4115
4116
0
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4117
0
  sym_hashes = elf_sym_hashes (abfd);
4118
4119
0
  rel = elf_section_data (sec)->relocs;
4120
4121
  /* Now examine each relocation.  */
4122
0
  for (erel = rel + sec->reloc_count; rel < erel; rel++)
4123
0
    {
4124
0
      struct elf_link_hash_entry *h;
4125
0
      unsigned long r_symndx;
4126
0
      struct bfinfdpic_relocs_info *picrel;
4127
0
      struct _bfinfdpic_dynamic_got_info *dinfo;
4128
4129
0
      if (ELF32_R_TYPE (rel->r_info) != R_BFIN_BYTE4_DATA
4130
0
    && ELF32_R_TYPE (rel->r_info) != R_BFIN_FUNCDESC)
4131
0
  continue;
4132
4133
0
      if (_bfd_elf_section_offset (sec->output_section->owner,
4134
0
           info, sec, rel->r_offset)
4135
0
    != (bfd_vma)-1)
4136
0
  continue;
4137
4138
0
      r_symndx = ELF32_R_SYM (rel->r_info);
4139
0
      if (r_symndx < symtab_hdr->sh_info)
4140
0
  h = NULL;
4141
0
      else
4142
0
  {
4143
0
    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4144
0
    while (h->root.type == bfd_link_hash_indirect
4145
0
     || h->root.type == bfd_link_hash_warning)
4146
0
      h = (struct elf_link_hash_entry *)h->root.u.i.link;
4147
0
  }
4148
4149
0
      if (h != NULL)
4150
0
  picrel = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info),
4151
0
              abfd, h,
4152
0
              rel->r_addend, NO_INSERT);
4153
0
      else
4154
0
  picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info (info),
4155
0
             abfd, r_symndx,
4156
0
             rel->r_addend, NO_INSERT);
4157
4158
0
      if (! picrel)
4159
0
  return false;
4160
4161
0
      *changed = true;
4162
0
      dinfo = bfinfdpic_dynamic_got_plt_info (info);
4163
4164
0
      _bfinfdpic_count_relocs_fixups (picrel, dinfo, true);
4165
0
      if (ELF32_R_TYPE (rel->r_info) == R_BFIN_BYTE4_DATA)
4166
0
  picrel->relocs32--;
4167
0
      else /* we know (ELF32_R_TYPE (rel->r_info) == R_BFIN_FUNCDESC) */
4168
0
  picrel->relocsfd--;
4169
0
      _bfinfdpic_count_relocs_fixups (picrel, dinfo, false);
4170
0
    }
4171
4172
0
  return true;
4173
0
}
4174
4175
static bool
4176
bfinfdpic_elf_discard_info (bfd *ibfd,
4177
         struct elf_reloc_cookie *cookie ATTRIBUTE_UNUSED,
4178
         struct bfd_link_info *info)
4179
0
{
4180
0
  bool changed = false;
4181
0
  asection *s;
4182
0
  bfd *obfd = NULL;
4183
4184
  /* Account for relaxation of .eh_frame section.  */
4185
0
  for (s = ibfd->sections; s; s = s->next)
4186
0
    if (s->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
4187
0
      {
4188
0
  if (!_bfinfdpic_check_discarded_relocs (ibfd, s, info, &changed))
4189
0
    return false;
4190
0
  obfd = s->output_section->owner;
4191
0
      }
4192
4193
0
  if (changed)
4194
0
    {
4195
0
      struct _bfinfdpic_dynamic_got_plt_info gpinfo;
4196
4197
0
      memset (&gpinfo, 0, sizeof (gpinfo));
4198
0
      memcpy (&gpinfo.g, bfinfdpic_dynamic_got_plt_info (info),
4199
0
        sizeof (gpinfo.g));
4200
4201
      /* Clear GOT and PLT assignments.  */
4202
0
      htab_traverse (bfinfdpic_relocs_info (info),
4203
0
         _bfinfdpic_reset_got_plt_entries,
4204
0
         NULL);
4205
4206
0
      if (!_bfinfdpic_size_got_plt (obfd, &gpinfo))
4207
0
  return false;
4208
0
    }
4209
4210
0
  return true;
4211
0
}
4212
4213
static bool
4214
elf32_bfinfdpic_finish_dynamic_sections (bfd *output_bfd,
4215
          struct bfd_link_info *info)
4216
0
{
4217
0
  bfd *dynobj;
4218
0
  asection *sdyn;
4219
4220
0
  dynobj = elf_hash_table (info)->dynobj;
4221
4222
0
  if (bfinfdpic_got_section (info))
4223
0
    {
4224
0
      BFD_ASSERT (bfinfdpic_gotrel_section (info)->size
4225
      /* PR 17334: It appears that the GOT section can end up
4226
         being bigger than the number of relocs.  Presumably
4227
         because some relocs have been deleted.  A test case has
4228
         yet to be generated for verify this, but in the meantime
4229
         the test below has been changed from == to >= so that
4230
         applications can continue to be built.  */
4231
0
      >= (bfinfdpic_gotrel_section (info)->reloc_count
4232
0
          * sizeof (Elf32_External_Rel)));
4233
4234
0
      if (bfinfdpic_gotfixup_section (info))
4235
0
  {
4236
0
    struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
4237
0
    bfd_vma got_value = hgot->root.u.def.value
4238
0
      + hgot->root.u.def.section->output_section->vma
4239
0
      + hgot->root.u.def.section->output_offset;
4240
4241
0
    _bfinfdpic_add_rofixup (output_bfd, bfinfdpic_gotfixup_section (info),
4242
0
         got_value, 0);
4243
4244
0
    if (bfinfdpic_gotfixup_section (info)->size
4245
0
        != (bfinfdpic_gotfixup_section (info)->reloc_count * 4))
4246
0
      {
4247
0
        _bfd_error_handler
4248
0
    ("LINKER BUG: .rofixup section size mismatch");
4249
0
        return false;
4250
0
      }
4251
0
  }
4252
0
    }
4253
0
  if (elf_hash_table (info)->dynamic_sections_created)
4254
0
    {
4255
0
      BFD_ASSERT (bfinfdpic_pltrel_section (info)->size
4256
0
      == (bfinfdpic_pltrel_section (info)->reloc_count
4257
0
          * sizeof (Elf32_External_Rel)));
4258
0
    }
4259
4260
0
  sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4261
4262
0
  if (elf_hash_table (info)->dynamic_sections_created)
4263
0
    {
4264
0
      Elf32_External_Dyn * dyncon;
4265
0
      Elf32_External_Dyn * dynconend;
4266
4267
0
      BFD_ASSERT (sdyn != NULL);
4268
4269
0
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
4270
0
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4271
4272
0
      for (; dyncon < dynconend; dyncon++)
4273
0
  {
4274
0
    Elf_Internal_Dyn dyn;
4275
4276
0
    bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4277
4278
0
    switch (dyn.d_tag)
4279
0
      {
4280
0
      default:
4281
0
        break;
4282
4283
0
      case DT_PLTGOT:
4284
0
        dyn.d_un.d_ptr = bfinfdpic_got_section (info)->output_section->vma
4285
0
    + bfinfdpic_got_section (info)->output_offset
4286
0
    + bfinfdpic_got_initial_offset (info);
4287
0
        bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4288
0
        break;
4289
4290
0
      case DT_JMPREL:
4291
0
        dyn.d_un.d_ptr = bfinfdpic_pltrel_section (info)
4292
0
    ->output_section->vma
4293
0
    + bfinfdpic_pltrel_section (info)->output_offset;
4294
0
        bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4295
0
        break;
4296
4297
0
      case DT_PLTRELSZ:
4298
0
        dyn.d_un.d_val = bfinfdpic_pltrel_section (info)->size;
4299
0
        bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4300
0
        break;
4301
0
      }
4302
0
  }
4303
0
    }
4304
4305
0
  return true;
4306
0
}
4307
4308
/* Adjust a symbol defined by a dynamic object and referenced by a
4309
   regular object.  */
4310
4311
static bool
4312
elf32_bfinfdpic_adjust_dynamic_symbol (struct bfd_link_info *info,
4313
               struct elf_link_hash_entry *h)
4314
0
{
4315
0
  bfd * dynobj;
4316
4317
0
  dynobj = elf_hash_table (info)->dynobj;
4318
4319
  /* Make sure we know what is going on here.  */
4320
0
  BFD_ASSERT (dynobj != NULL
4321
0
        && (h->is_weakalias
4322
0
      || (h->def_dynamic
4323
0
          && h->ref_regular
4324
0
          && !h->def_regular)));
4325
4326
  /* If this is a weak symbol, and there is a real definition, the
4327
     processor independent code will have arranged for us to see the
4328
     real definition first, and we can just use the same value.  */
4329
0
  if (h->is_weakalias)
4330
0
    {
4331
0
      struct elf_link_hash_entry *def = weakdef (h);
4332
0
      BFD_ASSERT (def->root.type == bfd_link_hash_defined);
4333
0
      h->root.u.def.section = def->root.u.def.section;
4334
0
      h->root.u.def.value = def->root.u.def.value;
4335
0
    }
4336
4337
0
  return true;
4338
0
}
4339
4340
/* Perform any actions needed for dynamic symbols.  */
4341
4342
static bool
4343
elf32_bfinfdpic_finish_dynamic_symbol
4344
(bfd *output_bfd ATTRIBUTE_UNUSED,
4345
 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4346
 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
4347
 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4348
0
{
4349
0
  return true;
4350
0
}
4351
4352
/* Decide whether to attempt to turn absptr or lsda encodings in
4353
   shared libraries into pcrel within the given input section.  */
4354
4355
static bool
4356
bfinfdpic_elf_use_relative_eh_frame
4357
(bfd *input_bfd ATTRIBUTE_UNUSED,
4358
 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4359
 asection *eh_frame_section ATTRIBUTE_UNUSED)
4360
0
{
4361
  /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
4362
0
  return false;
4363
0
}
4364
4365
/* Adjust the contents of an eh_frame_hdr section before they're output.  */
4366
4367
static bfd_byte
4368
bfinfdpic_elf_encode_eh_address (bfd *abfd,
4369
        struct bfd_link_info *info,
4370
        asection *osec, bfd_vma offset,
4371
        asection *loc_sec, bfd_vma loc_offset,
4372
        bfd_vma *encoded)
4373
0
{
4374
0
  struct elf_link_hash_entry *h;
4375
4376
0
  h = elf_hash_table (info)->hgot;
4377
0
  BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
4378
4379
0
  if (! h || (_bfinfdpic_osec_to_segment (abfd, osec)
4380
0
        == _bfinfdpic_osec_to_segment (abfd, loc_sec->output_section)))
4381
0
    return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
4382
0
               loc_sec, loc_offset, encoded);
4383
4384
0
  BFD_ASSERT (_bfinfdpic_osec_to_segment (abfd, osec)
4385
0
        == (_bfinfdpic_osec_to_segment
4386
0
      (abfd, h->root.u.def.section->output_section)));
4387
4388
0
  *encoded = osec->vma + offset
4389
0
    - (h->root.u.def.value
4390
0
       + h->root.u.def.section->output_section->vma
4391
0
       + h->root.u.def.section->output_offset);
4392
4393
0
  return DW_EH_PE_datarel | DW_EH_PE_sdata4;
4394
0
}
4395
4396
4397
4398
/* Look through the relocs for a section during the first phase.
4399
4400
   Besides handling virtual table relocs for gc, we have to deal with
4401
   all sorts of PIC-related relocations.  We describe below the
4402
   general plan on how to handle such relocations, even though we only
4403
   collect information at this point, storing them in hash tables for
4404
   perusal of later passes.
4405
4406
   32 relocations are propagated to the linker output when creating
4407
   position-independent output.  LO16 and HI16 relocations are not
4408
   supposed to be encountered in this case.
4409
4410
   LABEL16 should always be resolvable by the linker, since it's only
4411
   used by branches.
4412
4413
   LABEL24, on the other hand, is used by calls.  If it turns out that
4414
   the target of a call is a dynamic symbol, a PLT entry must be
4415
   created for it, which triggers the creation of a private function
4416
   descriptor and, unless lazy binding is disabled, a lazy PLT entry.
4417
4418
   GPREL relocations require the referenced symbol to be in the same
4419
   segment as _gp, but this can only be checked later.
4420
4421
   All GOT, GOTOFF and FUNCDESC relocations require a .got section to
4422
   exist.  LABEL24 might as well, since it may require a PLT entry,
4423
   that will require a got.
4424
4425
   Non-FUNCDESC GOT relocations require a GOT entry to be created
4426
   regardless of whether the symbol is dynamic.  However, since a
4427
   global symbol that turns out to not be exported may have the same
4428
   address of a non-dynamic symbol, we don't assign GOT entries at
4429
   this point, such that we can share them in this case.  A relocation
4430
   for the GOT entry always has to be created, be it to offset a
4431
   private symbol by the section load address, be it to get the symbol
4432
   resolved dynamically.
4433
4434
   FUNCDESC GOT relocations require a GOT entry to be created, and
4435
   handled as if a FUNCDESC relocation was applied to the GOT entry in
4436
   an object file.
4437
4438
   FUNCDESC relocations referencing a symbol that turns out to NOT be
4439
   dynamic cause a private function descriptor to be created.  The
4440
   FUNCDESC relocation then decays to a 32 relocation that points at
4441
   the private descriptor.  If the symbol is dynamic, the FUNCDESC
4442
   relocation is propagated to the linker output, such that the
4443
   dynamic linker creates the canonical descriptor, pointing to the
4444
   dynamically-resolved definition of the function.
4445
4446
   Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
4447
   symbols that are assigned to the same segment as the GOT, but we
4448
   can only check this later, after we know the complete set of
4449
   symbols defined and/or exported.
4450
4451
   FUNCDESC GOTOFF relocations require a function descriptor to be
4452
   created and, unless lazy binding is disabled or the symbol is not
4453
   dynamic, a lazy PLT entry.  Since we can't tell at this point
4454
   whether a symbol is going to be dynamic, we have to decide later
4455
   whether to create a lazy PLT entry or bind the descriptor directly
4456
   to the private function.
4457
4458
   FUNCDESC_VALUE relocations are not supposed to be present in object
4459
   files, but they may very well be simply propagated to the linker
4460
   output, since they have no side effect.
4461
4462
4463
   A function descriptor always requires a FUNCDESC_VALUE relocation.
4464
   Whether it's in .plt.rel or not depends on whether lazy binding is
4465
   enabled and on whether the referenced symbol is dynamic.
4466
4467
   The existence of a lazy PLT requires the resolverStub lazy PLT
4468
   entry to be present.
4469
4470
4471
   As for assignment of GOT, PLT and lazy PLT entries, and private
4472
   descriptors, we might do them all sequentially, but we can do
4473
   better than that.  For example, we can place GOT entries and
4474
   private function descriptors referenced using 12-bit operands
4475
   closer to the PIC register value, such that these relocations don't
4476
   overflow.  Those that are only referenced with LO16 relocations
4477
   could come next, but we may as well place PLT-required function
4478
   descriptors in the 12-bit range to make them shorter.  Symbols
4479
   referenced with LO16/HI16 may come next, but we may place
4480
   additional function descriptors in the 16-bit range if we can
4481
   reliably tell that we've already placed entries that are ever
4482
   referenced with only LO16.  PLT entries are therefore generated as
4483
   small as possible, while not introducing relocation overflows in
4484
   GOT or FUNCDESC_GOTOFF relocations.  Lazy PLT entries could be
4485
   generated before or after PLT entries, but not intermingled with
4486
   them, such that we can have more lazy PLT entries in range for a
4487
   branch to the resolverStub.  The resolverStub should be emitted at
4488
   the most distant location from the first lazy PLT entry such that
4489
   it's still in range for a branch, or closer, if there isn't a need
4490
   for so many lazy PLT entries.  Additional lazy PLT entries may be
4491
   emitted after the resolverStub, as long as branches are still in
4492
   range.  If the branch goes out of range, longer lazy PLT entries
4493
   are emitted.
4494
4495
   We could further optimize PLT and lazy PLT entries by giving them
4496
   priority in assignment to closer-to-gr17 locations depending on the
4497
   number of occurrences of references to them (assuming a function
4498
   that's called more often is more important for performance, so its
4499
   PLT entry should be faster), or taking hints from the compiler.
4500
   Given infinite time and money... :-)  */
4501
4502
static bool
4503
bfinfdpic_check_relocs (bfd *abfd, struct bfd_link_info *info,
4504
      asection *sec, const Elf_Internal_Rela *relocs)
4505
0
{
4506
0
  Elf_Internal_Shdr *symtab_hdr;
4507
0
  struct elf_link_hash_entry **sym_hashes;
4508
0
  const Elf_Internal_Rela *rel;
4509
0
  const Elf_Internal_Rela *rel_end;
4510
0
  bfd *dynobj;
4511
0
  struct bfinfdpic_relocs_info *picrel;
4512
4513
0
  if (bfd_link_relocatable (info))
4514
0
    return true;
4515
4516
0
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4517
0
  sym_hashes = elf_sym_hashes (abfd);
4518
4519
0
  dynobj = elf_hash_table (info)->dynobj;
4520
0
  rel_end = relocs + sec->reloc_count;
4521
0
  for (rel = relocs; rel < rel_end; rel++)
4522
0
    {
4523
0
      struct elf_link_hash_entry *h;
4524
0
      unsigned long r_symndx;
4525
4526
0
      r_symndx = ELF32_R_SYM (rel->r_info);
4527
0
      if (r_symndx < symtab_hdr->sh_info)
4528
0
  h = NULL;
4529
0
      else
4530
0
  {
4531
0
    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4532
0
    while (h->root.type == bfd_link_hash_indirect
4533
0
     || h->root.type == bfd_link_hash_warning)
4534
0
      h = (struct elf_link_hash_entry *) h->root.u.i.link;
4535
0
  }
4536
4537
0
      switch (ELF32_R_TYPE (rel->r_info))
4538
0
  {
4539
0
  case R_BFIN_GOT17M4:
4540
0
  case R_BFIN_GOTHI:
4541
0
  case R_BFIN_GOTLO:
4542
0
  case R_BFIN_FUNCDESC_GOT17M4:
4543
0
  case R_BFIN_FUNCDESC_GOTHI:
4544
0
  case R_BFIN_FUNCDESC_GOTLO:
4545
0
  case R_BFIN_GOTOFF17M4:
4546
0
  case R_BFIN_GOTOFFHI:
4547
0
  case R_BFIN_GOTOFFLO:
4548
0
  case R_BFIN_FUNCDESC_GOTOFF17M4:
4549
0
  case R_BFIN_FUNCDESC_GOTOFFHI:
4550
0
  case R_BFIN_FUNCDESC_GOTOFFLO:
4551
0
  case R_BFIN_FUNCDESC:
4552
0
  case R_BFIN_FUNCDESC_VALUE:
4553
0
    if (! IS_FDPIC (abfd))
4554
0
      goto bad_reloc;
4555
    /* Fall through.  */
4556
0
  case R_BFIN_PCREL24:
4557
0
  case R_BFIN_PCREL24_JUMP_L:
4558
0
  case R_BFIN_BYTE4_DATA:
4559
0
    if (IS_FDPIC (abfd) && ! dynobj)
4560
0
      {
4561
0
        elf_hash_table (info)->dynobj = dynobj = abfd;
4562
0
        if (! _bfin_create_got_section (abfd, info))
4563
0
    return false;
4564
0
      }
4565
0
    if (! IS_FDPIC (abfd))
4566
0
      {
4567
0
        picrel = NULL;
4568
0
        break;
4569
0
      }
4570
0
    if (h != NULL)
4571
0
      {
4572
0
        if (h->dynindx == -1)
4573
0
    switch (ELF_ST_VISIBILITY (h->other))
4574
0
      {
4575
0
      case STV_INTERNAL:
4576
0
      case STV_HIDDEN:
4577
0
        break;
4578
0
      default:
4579
0
        bfd_elf_link_record_dynamic_symbol (info, h);
4580
0
        break;
4581
0
      }
4582
0
        picrel
4583
0
    = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info),
4584
0
               abfd, h,
4585
0
               rel->r_addend, INSERT);
4586
0
      }
4587
0
    else
4588
0
      picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
4589
0
                 (info), abfd, r_symndx,
4590
0
                 rel->r_addend, INSERT);
4591
0
    if (! picrel)
4592
0
      return false;
4593
0
    break;
4594
4595
0
  default:
4596
0
    picrel = NULL;
4597
0
    break;
4598
0
  }
4599
4600
0
      switch (ELF32_R_TYPE (rel->r_info))
4601
0
  {
4602
0
  case R_BFIN_PCREL24:
4603
0
  case R_BFIN_PCREL24_JUMP_L:
4604
0
    if (IS_FDPIC (abfd))
4605
0
      picrel->call++;
4606
0
    break;
4607
4608
0
  case R_BFIN_FUNCDESC_VALUE:
4609
0
    picrel->relocsfdv++;
4610
0
    if (bfd_section_flags (sec) & SEC_ALLOC)
4611
0
      picrel->relocs32--;
4612
    /* Fall through.  */
4613
4614
0
  case R_BFIN_BYTE4_DATA:
4615
0
    if (! IS_FDPIC (abfd))
4616
0
      break;
4617
4618
0
    picrel->sym++;
4619
0
    if (bfd_section_flags (sec) & SEC_ALLOC)
4620
0
      picrel->relocs32++;
4621
0
    break;
4622
4623
0
  case R_BFIN_GOT17M4:
4624
0
    picrel->got17m4++;
4625
0
    break;
4626
4627
0
  case R_BFIN_GOTHI:
4628
0
  case R_BFIN_GOTLO:
4629
0
    picrel->gothilo++;
4630
0
    break;
4631
4632
0
  case R_BFIN_FUNCDESC_GOT17M4:
4633
0
    picrel->fdgot17m4++;
4634
0
    break;
4635
4636
0
  case R_BFIN_FUNCDESC_GOTHI:
4637
0
  case R_BFIN_FUNCDESC_GOTLO:
4638
0
    picrel->fdgothilo++;
4639
0
    break;
4640
4641
0
  case R_BFIN_GOTOFF17M4:
4642
0
  case R_BFIN_GOTOFFHI:
4643
0
  case R_BFIN_GOTOFFLO:
4644
0
    picrel->gotoff++;
4645
0
    break;
4646
4647
0
  case R_BFIN_FUNCDESC_GOTOFF17M4:
4648
0
    picrel->fdgoff17m4++;
4649
0
    break;
4650
4651
0
  case R_BFIN_FUNCDESC_GOTOFFHI:
4652
0
  case R_BFIN_FUNCDESC_GOTOFFLO:
4653
0
    picrel->fdgoffhilo++;
4654
0
    break;
4655
4656
0
  case R_BFIN_FUNCDESC:
4657
0
    picrel->fd++;
4658
0
    picrel->relocsfd++;
4659
0
    break;
4660
4661
  /* This relocation describes the C++ object vtable hierarchy.
4662
     Reconstruct it for later use during GC.  */
4663
0
  case R_BFIN_GNU_VTINHERIT:
4664
0
    if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4665
0
      return false;
4666
0
    break;
4667
4668
  /* This relocation describes which C++ vtable entries are actually
4669
     used.  Record for later use during GC.  */
4670
0
  case R_BFIN_GNU_VTENTRY:
4671
0
    BFD_ASSERT (h != NULL);
4672
0
    if (h != NULL
4673
0
        && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4674
0
      return false;
4675
0
    break;
4676
4677
0
  case R_BFIN_HUIMM16:
4678
0
  case R_BFIN_LUIMM16:
4679
0
  case R_BFIN_PCREL12_JUMP_S:
4680
0
  case R_BFIN_PCREL10:
4681
0
    break;
4682
4683
0
  default:
4684
0
  bad_reloc:
4685
0
    _bfd_error_handler
4686
      /* xgettext:c-format */
4687
0
      (_("%pB: unsupported relocation type %#x"),
4688
0
       abfd, (int) ELF32_R_TYPE (rel->r_info));
4689
0
    return false;
4690
0
  }
4691
0
    }
4692
4693
0
  return true;
4694
0
}
4695
4696
/* Set the right machine number for a Blackfin ELF file.  */
4697
4698
static bool
4699
elf32_bfin_object_p (bfd *abfd)
4700
14
{
4701
14
  bfd_default_set_arch_mach (abfd, bfd_arch_bfin, 0);
4702
14
  return (((elf_elfheader (abfd)->e_flags & EF_BFIN_FDPIC) != 0)
4703
14
    == (IS_FDPIC (abfd)));
4704
14
}
4705
4706
static bool
4707
elf32_bfin_set_private_flags (bfd * abfd, flagword flags)
4708
0
{
4709
0
  elf_elfheader (abfd)->e_flags = flags;
4710
0
  elf_flags_init (abfd) = true;
4711
0
  return true;
4712
0
}
4713
4714
/* Display the flags field.  */
4715
static bool
4716
elf32_bfin_print_private_bfd_data (bfd * abfd, void * ptr)
4717
2
{
4718
2
  FILE *file = (FILE *) ptr;
4719
2
  flagword flags;
4720
4721
2
  BFD_ASSERT (abfd != NULL && ptr != NULL);
4722
4723
  /* Print normal ELF private data.  */
4724
2
  _bfd_elf_print_private_bfd_data (abfd, ptr);
4725
4726
2
  flags = elf_elfheader (abfd)->e_flags;
4727
4728
  /* xgettext:c-format */
4729
2
  fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4730
4731
2
  if (flags & EF_BFIN_PIC)
4732
0
    fprintf (file, " -fpic");
4733
4734
2
  if (flags & EF_BFIN_FDPIC)
4735
1
    fprintf (file, " -mfdpic");
4736
4737
2
  fputc ('\n', file);
4738
4739
2
  return true;
4740
2
}
4741
4742
/* Merge backend specific data from an object file to the output
4743
   object file when linking.  */
4744
4745
static bool
4746
elf32_bfin_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
4747
0
{
4748
0
  bfd *obfd = info->output_bfd;
4749
0
  flagword old_flags, new_flags;
4750
0
  bool error = false;
4751
4752
  /* FIXME: What should be checked when linking shared libraries?  */
4753
0
  if ((ibfd->flags & DYNAMIC) != 0)
4754
0
    return true;
4755
4756
0
  new_flags = elf_elfheader (ibfd)->e_flags;
4757
0
  old_flags = elf_elfheader (obfd)->e_flags;
4758
4759
0
  if (new_flags & EF_BFIN_FDPIC)
4760
0
    new_flags &= ~EF_BFIN_PIC;
4761
4762
0
#ifndef DEBUG
4763
0
  if (0)
4764
0
#endif
4765
0
  _bfd_error_handler
4766
0
    ("old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s, filename = %pB",
4767
0
     old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no", ibfd);
4768
4769
0
  if (!elf_flags_init (obfd))      /* First call, no flags set.  */
4770
0
    {
4771
0
      elf_flags_init (obfd) = true;
4772
0
      elf_elfheader (obfd)->e_flags = new_flags;
4773
0
    }
4774
4775
0
  if (((new_flags & EF_BFIN_FDPIC) == 0) != (! IS_FDPIC (obfd)))
4776
0
    {
4777
0
      error = true;
4778
0
      if (IS_FDPIC (obfd))
4779
0
  _bfd_error_handler
4780
0
    (_("%pB: cannot link non-fdpic object file into fdpic executable"),
4781
0
     ibfd);
4782
0
      else
4783
0
  _bfd_error_handler
4784
0
    (_("%pB: cannot link fdpic object file into non-fdpic executable"),
4785
0
     ibfd);
4786
0
    }
4787
4788
0
  if (error)
4789
0
    bfd_set_error (bfd_error_bad_value);
4790
4791
0
  return !error;
4792
0
}
4793

4794
/* bfin ELF linker hash entry.  */
4795
4796
struct bfin_link_hash_entry
4797
{
4798
  struct elf_link_hash_entry root;
4799
4800
  /* Number of PC relative relocs copied for this symbol.  */
4801
  struct bfin_pcrel_relocs_copied *pcrel_relocs_copied;
4802
};
4803
4804
0
#define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent))
4805
4806
static struct bfd_hash_entry *
4807
bfin_link_hash_newfunc (struct bfd_hash_entry *entry,
4808
      struct bfd_hash_table *table, const char *string)
4809
0
{
4810
0
  struct bfd_hash_entry *ret = entry;
4811
4812
  /* Allocate the structure if it has not already been allocated by a
4813
     subclass.  */
4814
0
  if (ret == NULL)
4815
0
    ret = bfd_hash_allocate (table, sizeof (struct bfin_link_hash_entry));
4816
0
  if (ret == NULL)
4817
0
    return ret;
4818
4819
  /* Call the allocation method of the superclass.  */
4820
0
  ret = _bfd_elf_link_hash_newfunc (ret, table, string);
4821
0
  if (ret != NULL)
4822
0
    bfin_hash_entry (ret)->pcrel_relocs_copied = NULL;
4823
4824
0
  return ret;
4825
0
}
4826
4827
/* Create an bfin ELF linker hash table.  */
4828
4829
static struct bfd_link_hash_table *
4830
bfin_link_hash_table_create (bfd * abfd)
4831
0
{
4832
0
  struct elf_link_hash_table *ret;
4833
0
  size_t amt = sizeof (struct elf_link_hash_table);
4834
4835
0
  ret = bfd_zmalloc (amt);
4836
0
  if (ret == NULL)
4837
0
    return NULL;
4838
4839
0
  if (!_bfd_elf_link_hash_table_init (ret, abfd, bfin_link_hash_newfunc,
4840
0
              sizeof (struct elf_link_hash_entry),
4841
0
              BFIN_ELF_DATA))
4842
0
    {
4843
0
      free (ret);
4844
0
      return NULL;
4845
0
    }
4846
4847
0
  return &ret->root;
4848
0
}
4849
4850
/* The size in bytes of an entry in the procedure linkage table.  */
4851
4852
/* Finish up the dynamic sections.  */
4853
4854
static bool
4855
bfin_finish_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
4856
            struct bfd_link_info *info)
4857
0
{
4858
0
  bfd *dynobj;
4859
0
  asection *sdyn;
4860
4861
0
  dynobj = elf_hash_table (info)->dynobj;
4862
4863
0
  sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4864
4865
0
  if (elf_hash_table (info)->dynamic_sections_created)
4866
0
    {
4867
0
      Elf32_External_Dyn *dyncon, *dynconend;
4868
4869
0
      BFD_ASSERT (sdyn != NULL);
4870
4871
0
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
4872
0
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4873
0
      for (; dyncon < dynconend; dyncon++)
4874
0
  {
4875
0
    Elf_Internal_Dyn dyn;
4876
4877
0
    bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4878
4879
0
  }
4880
4881
0
    }
4882
0
  return true;
4883
0
}
4884
4885
/* Finish up dynamic symbol handling.  We set the contents of various
4886
   dynamic sections here.  */
4887
4888
static bool
4889
bfin_finish_dynamic_symbol (bfd * output_bfd,
4890
          struct bfd_link_info *info,
4891
          struct elf_link_hash_entry *h,
4892
          Elf_Internal_Sym * sym)
4893
0
{
4894
0
  if (h->got.offset != (bfd_vma) - 1)
4895
0
    {
4896
0
      asection *sgot;
4897
0
      asection *srela;
4898
0
      Elf_Internal_Rela rela;
4899
0
      bfd_byte *loc;
4900
4901
      /* This symbol has an entry in the global offset table.
4902
   Set it up.  */
4903
4904
0
      sgot = elf_hash_table (info)->sgot;
4905
0
      srela = elf_hash_table (info)->srelgot;
4906
0
      BFD_ASSERT (sgot != NULL && srela != NULL);
4907
4908
0
      rela.r_offset = (sgot->output_section->vma
4909
0
           + sgot->output_offset
4910
0
           + (h->got.offset & ~(bfd_vma) 1));
4911
4912
      /* If this is a -Bsymbolic link, and the symbol is defined
4913
   locally, we just want to emit a RELATIVE reloc.  Likewise if
4914
   the symbol was forced to be local because of a version file.
4915
   The entry in the global offset table will already have been
4916
   initialized in the relocate_section function.  */
4917
0
      if (bfd_link_pic (info)
4918
0
    && (info->symbolic
4919
0
        || h->dynindx == -1 || h->forced_local) && h->def_regular)
4920
0
  {
4921
0
    _bfd_error_handler (_("*** check this relocation %s"), __func__);
4922
0
    rela.r_info = ELF32_R_INFO (0, R_BFIN_PCREL24);
4923
0
    rela.r_addend = bfd_get_signed_32 (output_bfd,
4924
0
               (sgot->contents
4925
0
                +
4926
0
                (h->got.
4927
0
                 offset & ~(bfd_vma) 1)));
4928
0
  }
4929
0
      else
4930
0
  {
4931
0
    bfd_put_32 (output_bfd, (bfd_vma) 0,
4932
0
          sgot->contents + (h->got.offset & ~(bfd_vma) 1));
4933
0
    rela.r_info = ELF32_R_INFO (h->dynindx, R_BFIN_GOT);
4934
0
    rela.r_addend = 0;
4935
0
  }
4936
4937
0
      loc = srela->contents;
4938
0
      loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
4939
0
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4940
0
    }
4941
4942
0
  if (h->needs_copy)
4943
0
    {
4944
0
      BFD_ASSERT (0);
4945
0
    }
4946
  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
4947
0
  if (strcmp (h->root.root.string, "__DYNAMIC") == 0
4948
0
      || h == elf_hash_table (info)->hgot)
4949
0
    sym->st_shndx = SHN_ABS;
4950
4951
0
  return true;
4952
0
}
4953
4954
/* Adjust a symbol defined by a dynamic object and referenced by a
4955
   regular object.  The current definition is in some section of the
4956
   dynamic object, but we're not including those sections.  We have to
4957
   change the definition to something the rest of the link can
4958
   understand.  */
4959
4960
static bool
4961
bfin_adjust_dynamic_symbol (struct bfd_link_info *info,
4962
          struct elf_link_hash_entry *h)
4963
0
{
4964
0
  bfd *dynobj;
4965
0
  asection *s;
4966
0
  unsigned int power_of_two;
4967
4968
0
  dynobj = elf_hash_table (info)->dynobj;
4969
4970
  /* Make sure we know what is going on here.  */
4971
0
  BFD_ASSERT (dynobj != NULL
4972
0
        && (h->needs_plt
4973
0
      || h->is_weakalias
4974
0
      || (h->def_dynamic && h->ref_regular && !h->def_regular)));
4975
4976
  /* If this is a function, put it in the procedure linkage table.  We
4977
     will fill in the contents of the procedure linkage table later,
4978
     when we know the address of the .got section.  */
4979
0
  if (h->type == STT_FUNC || h->needs_plt)
4980
0
    {
4981
0
      BFD_ASSERT(0);
4982
0
    }
4983
4984
  /* If this is a weak symbol, and there is a real definition, the
4985
     processor independent code will have arranged for us to see the
4986
     real definition first, and we can just use the same value.  */
4987
0
  if (h->is_weakalias)
4988
0
    {
4989
0
      struct elf_link_hash_entry *def = weakdef (h);
4990
0
      BFD_ASSERT (def->root.type == bfd_link_hash_defined);
4991
0
      h->root.u.def.section = def->root.u.def.section;
4992
0
      h->root.u.def.value = def->root.u.def.value;
4993
0
      return true;
4994
0
    }
4995
4996
  /* This is a reference to a symbol defined by a dynamic object which
4997
     is not a function.  */
4998
4999
  /* If we are creating a shared library, we must presume that the
5000
     only references to the symbol are via the global offset table.
5001
     For such cases we need not do anything here; the relocations will
5002
     be handled correctly by relocate_section.  */
5003
0
  if (bfd_link_pic (info))
5004
0
    return true;
5005
5006
  /* We must allocate the symbol in our .dynbss section, which will
5007
     become part of the .bss section of the executable.  There will be
5008
     an entry for this symbol in the .dynsym section.  The dynamic
5009
     object will contain position independent code, so all references
5010
     from the dynamic object to this symbol will go through the global
5011
     offset table.  The dynamic linker will use the .dynsym entry to
5012
     determine the address it must put in the global offset table, so
5013
     both the dynamic object and the regular object will refer to the
5014
     same memory location for the variable.  */
5015
5016
0
  s = bfd_get_linker_section (dynobj, ".dynbss");
5017
0
  BFD_ASSERT (s != NULL);
5018
5019
#if 0 /* Bfin does not currently have a COPY reloc.  */
5020
  /* We must generate a R_BFIN_COPY reloc to tell the dynamic linker to
5021
     copy the initial value out of the dynamic object and into the
5022
     runtime process image.  We need to remember the offset into the
5023
     .rela.bss section we are going to use.  */
5024
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5025
    {
5026
      asection *srel;
5027
5028
      srel = bfd_get_linker_section (dynobj, ".rela.bss");
5029
      BFD_ASSERT (srel != NULL);
5030
      srel->size += sizeof (Elf32_External_Rela);
5031
      h->needs_copy = 1;
5032
    }
5033
#else
5034
0
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5035
0
    {
5036
0
      _bfd_error_handler (_("the bfin target does not currently support the generation of copy relocations"));
5037
0
      return false;
5038
0
    }
5039
0
#endif
5040
  /* We need to figure out the alignment required for this symbol.  I
5041
     have no idea how ELF linkers handle this.  */
5042
0
  power_of_two = bfd_log2 (h->size);
5043
0
  if (power_of_two > 3)
5044
0
    power_of_two = 3;
5045
5046
  /* Apply the required alignment.  */
5047
0
  s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5048
0
  if (power_of_two > bfd_section_alignment (s))
5049
0
    {
5050
0
      if (!bfd_set_section_alignment (s, power_of_two))
5051
0
  return false;
5052
0
    }
5053
5054
  /* Define the symbol as being at this point in the section.  */
5055
0
  h->root.u.def.section = s;
5056
0
  h->root.u.def.value = s->size;
5057
5058
  /* Increment the section size to make room for the symbol.  */
5059
0
  s->size += h->size;
5060
5061
0
  return true;
5062
0
}
5063
5064
/* The bfin linker needs to keep track of the number of relocs that it
5065
   decides to copy in check_relocs for each symbol.  This is so that it
5066
   can discard PC relative relocs if it doesn't need them when linking
5067
   with -Bsymbolic.  We store the information in a field extending the
5068
   regular ELF linker hash table.  */
5069
5070
/* This structure keeps track of the number of PC relative relocs we have
5071
   copied for a given symbol.  */
5072
5073
struct bfin_pcrel_relocs_copied
5074
{
5075
  /* Next section.  */
5076
  struct bfin_pcrel_relocs_copied *next;
5077
  /* A section in dynobj.  */
5078
  asection *section;
5079
  /* Number of relocs copied in this section.  */
5080
  bfd_size_type count;
5081
};
5082
5083
/* This function is called via elf_link_hash_traverse if we are
5084
   creating a shared object.  In the -Bsymbolic case it discards the
5085
   space allocated to copy PC relative relocs against symbols which
5086
   are defined in regular objects.  For the normal shared case, it
5087
   discards space for pc-relative relocs that have become local due to
5088
   symbol visibility changes.  We allocated space for them in the
5089
   check_relocs routine, but we won't fill them in in the
5090
   relocate_section routine.
5091
5092
   We also check whether any of the remaining relocations apply
5093
   against a readonly section, and set the DF_TEXTREL flag in this
5094
   case.  */
5095
5096
static bool
5097
bfin_discard_copies (struct elf_link_hash_entry *h, void * inf)
5098
0
{
5099
0
  struct bfd_link_info *info = (struct bfd_link_info *) inf;
5100
0
  struct bfin_pcrel_relocs_copied *s;
5101
5102
0
  if (!h->def_regular || (!info->symbolic && !h->forced_local))
5103
0
    {
5104
0
      if ((info->flags & DF_TEXTREL) == 0)
5105
0
  {
5106
    /* Look for relocations against read-only sections.  */
5107
0
    for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5108
0
         s != NULL; s = s->next)
5109
0
      if ((s->section->flags & SEC_READONLY) != 0)
5110
0
        {
5111
0
    info->flags |= DF_TEXTREL;
5112
0
    break;
5113
0
        }
5114
0
  }
5115
5116
0
      return true;
5117
0
    }
5118
5119
0
  for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5120
0
       s != NULL; s = s->next)
5121
0
    s->section->size -= s->count * sizeof (Elf32_External_Rela);
5122
5123
0
  return true;
5124
0
}
5125
5126
static bool
5127
bfin_late_size_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
5128
       struct bfd_link_info *info)
5129
0
{
5130
0
  bfd *dynobj;
5131
0
  asection *s;
5132
0
  bool relocs;
5133
5134
0
  dynobj = elf_hash_table (info)->dynobj;
5135
0
  if (dynobj == NULL)
5136
0
    return true;
5137
5138
0
  if (elf_hash_table (info)->dynamic_sections_created)
5139
0
    {
5140
      /* Set the contents of the .interp section to the interpreter.  */
5141
0
      if (bfd_link_executable (info) && !info->nointerp)
5142
0
  {
5143
0
    s = bfd_get_linker_section (dynobj, ".interp");
5144
0
    BFD_ASSERT (s != NULL);
5145
0
    s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5146
0
    s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5147
0
  }
5148
0
    }
5149
0
  else
5150
0
    {
5151
      /* We may have created entries in the .rela.got section.
5152
   However, if we are not creating the dynamic sections, we will
5153
   not actually use these entries.  Reset the size of .rela.got,
5154
   which will cause it to get stripped from the output file
5155
   below.  */
5156
0
      s = elf_hash_table (info)->srelgot;
5157
0
      if (s != NULL)
5158
0
  s->size = 0;
5159
0
    }
5160
5161
  /* If this is a -Bsymbolic shared link, then we need to discard all
5162
     PC relative relocs against symbols defined in a regular object.
5163
     For the normal shared case we discard the PC relative relocs
5164
     against symbols that have become local due to visibility changes.
5165
     We allocated space for them in the check_relocs routine, but we
5166
     will not fill them in in the relocate_section routine.  */
5167
0
  if (bfd_link_pic (info))
5168
0
    elf_link_hash_traverse (elf_hash_table (info),
5169
0
          bfin_discard_copies, info);
5170
5171
  /* The check_relocs and adjust_dynamic_symbol entry points have
5172
     determined the sizes of the various dynamic sections.  Allocate
5173
     memory for them.  */
5174
0
  relocs = false;
5175
0
  for (s = dynobj->sections; s != NULL; s = s->next)
5176
0
    {
5177
0
      const char *name;
5178
0
      bool strip;
5179
5180
0
      if ((s->flags & SEC_LINKER_CREATED) == 0)
5181
0
  continue;
5182
5183
      /* It's OK to base decisions on the section name, because none
5184
   of the dynobj section names depend upon the input files.  */
5185
0
      name = bfd_section_name (s);
5186
5187
0
      strip = false;
5188
5189
0
       if (startswith (name, ".rela"))
5190
0
  {
5191
0
    if (s->size == 0)
5192
0
      {
5193
        /* If we don't need this section, strip it from the
5194
     output file.  This is mostly to handle .rela.bss and
5195
     .rela.plt.  We must create both sections in
5196
     create_dynamic_sections, because they must be created
5197
     before the linker maps input sections to output
5198
     sections.  The linker does that before
5199
     adjust_dynamic_symbol is called, and it is that
5200
     function which decides whether anything needs to go
5201
     into these sections.  */
5202
0
        strip = true;
5203
0
      }
5204
0
    else
5205
0
      {
5206
0
        relocs = true;
5207
5208
        /* We use the reloc_count field as a counter if we need
5209
     to copy relocs into the output file.  */
5210
0
        s->reloc_count = 0;
5211
0
      }
5212
0
  }
5213
0
      else if (! startswith (name, ".got"))
5214
0
  {
5215
    /* It's not one of our sections, so don't allocate space.  */
5216
0
    continue;
5217
0
  }
5218
5219
0
      if (strip)
5220
0
  {
5221
0
    s->flags |= SEC_EXCLUDE;
5222
0
    continue;
5223
0
  }
5224
5225
      /* Allocate memory for the section contents.  */
5226
      /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
5227
   Unused entries should be reclaimed before the section's contents
5228
   are written out, but at the moment this does not happen.  Thus in
5229
   order to prevent writing out garbage, we initialise the section's
5230
   contents to zero.  */
5231
0
      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5232
0
      if (s->contents == NULL && s->size != 0)
5233
0
  return false;
5234
0
    }
5235
5236
0
  if (elf_hash_table (info)->dynamic_sections_created)
5237
0
    {
5238
      /* Add some entries to the .dynamic section.  We fill in the
5239
   values later, in bfin_finish_dynamic_sections, but we
5240
   must add the entries now so that we get the correct size for
5241
   the .dynamic section.  The DT_DEBUG entry is filled in by the
5242
   dynamic linker and used by the debugger.  */
5243
0
#define add_dynamic_entry(TAG, VAL) \
5244
0
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5245
5246
0
      if (!bfd_link_pic (info))
5247
0
  {
5248
0
    if (!add_dynamic_entry (DT_DEBUG, 0))
5249
0
      return false;
5250
0
  }
5251
5252
5253
0
      if (relocs)
5254
0
  {
5255
0
    if (!add_dynamic_entry (DT_RELA, 0)
5256
0
        || !add_dynamic_entry (DT_RELASZ, 0)
5257
0
        || !add_dynamic_entry (DT_RELAENT,
5258
0
             sizeof (Elf32_External_Rela)))
5259
0
      return false;
5260
0
  }
5261
5262
0
      if ((info->flags & DF_TEXTREL) != 0)
5263
0
  {
5264
0
    if (!add_dynamic_entry (DT_TEXTREL, 0))
5265
0
      return false;
5266
0
  }
5267
0
    }
5268
0
#undef add_dynamic_entry
5269
5270
0
  return true;
5271
0
}
5272

5273
/* Given a .data section and a .emreloc in-memory section, store
5274
   relocation information into the .emreloc section which can be
5275
   used at runtime to relocate the section.  This is called by the
5276
   linker when the --embedded-relocs switch is used.  This is called
5277
   after the add_symbols entry point has been called for all the
5278
   objects, and before the final_link entry point is called.  */
5279
5280
bool
5281
bfd_bfin_elf32_create_embedded_relocs (bfd *abfd,
5282
               struct bfd_link_info *info,
5283
               asection *datasec,
5284
               asection *relsec,
5285
               char **errmsg)
5286
0
{
5287
0
  Elf_Internal_Shdr *symtab_hdr;
5288
0
  Elf_Internal_Sym *isymbuf = NULL;
5289
0
  Elf_Internal_Rela *internal_relocs = NULL;
5290
0
  Elf_Internal_Rela *irel, *irelend;
5291
0
  bfd_byte *p;
5292
0
  bfd_size_type amt;
5293
5294
0
  BFD_ASSERT (! bfd_link_relocatable (info));
5295
5296
0
  *errmsg = NULL;
5297
5298
0
  if (datasec->reloc_count == 0)
5299
0
    return true;
5300
5301
0
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5302
5303
  /* Get a copy of the native relocations.  */
5304
0
  internal_relocs = (_bfd_elf_link_read_relocs
5305
0
         (abfd, datasec, NULL, (Elf_Internal_Rela *) NULL,
5306
0
          info->keep_memory));
5307
0
  if (internal_relocs == NULL)
5308
0
    goto error_return;
5309
5310
0
  amt = (bfd_size_type) datasec->reloc_count * 12;
5311
0
  relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
5312
0
  if (relsec->contents == NULL)
5313
0
    goto error_return;
5314
5315
0
  p = relsec->contents;
5316
5317
0
  irelend = internal_relocs + datasec->reloc_count;
5318
0
  for (irel = internal_relocs; irel < irelend; irel++, p += 12)
5319
0
    {
5320
0
      asection *targetsec;
5321
5322
      /* We are going to write a four byte longword into the runtime
5323
       reloc section.  The longword will be the address in the data
5324
       section which must be relocated.  It is followed by the name
5325
       of the target section NUL-padded or truncated to 8
5326
       characters.  */
5327
5328
      /* We can only relocate absolute longword relocs at run time.  */
5329
0
      if (ELF32_R_TYPE (irel->r_info) != (int) R_BFIN_BYTE4_DATA)
5330
0
  {
5331
0
    *errmsg = _("unsupported relocation type");
5332
0
    bfd_set_error (bfd_error_bad_value);
5333
0
    goto error_return;
5334
0
  }
5335
5336
      /* Get the target section referred to by the reloc.  */
5337
0
      if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
5338
0
  {
5339
    /* A local symbol.  */
5340
0
    Elf_Internal_Sym *isym;
5341
5342
    /* Read this BFD's local symbols if we haven't done so already.  */
5343
0
    if (isymbuf == NULL)
5344
0
      {
5345
0
        isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5346
0
        if (isymbuf == NULL)
5347
0
    isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5348
0
            symtab_hdr->sh_info, 0,
5349
0
            NULL, NULL, NULL);
5350
0
        if (isymbuf == NULL)
5351
0
    goto error_return;
5352
0
      }
5353
5354
0
    isym = isymbuf + ELF32_R_SYM (irel->r_info);
5355
0
    targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
5356
0
  }
5357
0
      else
5358
0
  {
5359
0
    unsigned long indx;
5360
0
    struct elf_link_hash_entry *h;
5361
5362
    /* An external symbol.  */
5363
0
    indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
5364
0
    h = elf_sym_hashes (abfd)[indx];
5365
0
    BFD_ASSERT (h != NULL);
5366
0
    if (h->root.type == bfd_link_hash_defined
5367
0
        || h->root.type == bfd_link_hash_defweak)
5368
0
      targetsec = h->root.u.def.section;
5369
0
    else
5370
0
      targetsec = NULL;
5371
0
  }
5372
5373
0
      bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
5374
0
      memset (p + 4, 0, 8);
5375
0
      if (targetsec != NULL)
5376
0
  strncpy ((char *) p + 4, targetsec->output_section->name, 8);
5377
0
    }
5378
5379
0
  if (symtab_hdr->contents != (unsigned char *) isymbuf)
5380
0
    free (isymbuf);
5381
0
  if (elf_section_data (datasec)->relocs != internal_relocs)
5382
0
    free (internal_relocs);
5383
0
  return true;
5384
5385
0
 error_return:
5386
0
  if (symtab_hdr->contents != (unsigned char *) isymbuf)
5387
0
    free (isymbuf);
5388
0
  if (elf_section_data (datasec)->relocs != internal_relocs)
5389
0
    free (internal_relocs);
5390
0
  return false;
5391
0
}
5392
5393
struct bfd_elf_special_section const elf32_bfin_special_sections[] =
5394
{
5395
  { ".l1.text",   8, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
5396
  { ".l1.data",   8, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
5397
  { NULL,   0,  0, 0,      0 }
5398
};
5399
5400

5401
#define TARGET_LITTLE_SYM   bfin_elf32_vec
5402
#define TARGET_LITTLE_NAME    "elf32-bfin"
5403
#define ELF_ARCH      bfd_arch_bfin
5404
#define ELF_TARGET_ID     BFIN_ELF_DATA
5405
#define ELF_MACHINE_CODE    EM_BLACKFIN
5406
#define ELF_MAXPAGESIZE     0x1000
5407
#define elf_symbol_leading_char   '_'
5408
5409
#define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup
5410
#define bfd_elf32_bfd_reloc_name_lookup \
5411
          bfin_bfd_reloc_name_lookup
5412
#define elf_info_to_howto   bfin_info_to_howto
5413
#define elf_info_to_howto_rel   NULL
5414
#define elf_backend_object_p    elf32_bfin_object_p
5415
5416
#define bfd_elf32_bfd_is_local_label_name \
5417
          bfin_is_local_label_name
5418
5419
#define elf_backend_create_dynamic_sections \
5420
          _bfd_elf_create_dynamic_sections
5421
#define bfd_elf32_bfd_link_hash_table_create \
5422
          bfin_link_hash_table_create
5423
#define bfd_elf32_bfd_final_link  bfd_elf_gc_common_final_link
5424
5425
#define elf_backend_check_relocs  bfin_check_relocs
5426
#define elf_backend_adjust_dynamic_symbol \
5427
          bfin_adjust_dynamic_symbol
5428
#define elf_backend_late_size_sections  bfin_late_size_sections
5429
#define elf_backend_relocate_section  bfin_relocate_section
5430
#define elf_backend_finish_dynamic_symbol \
5431
          bfin_finish_dynamic_symbol
5432
#define elf_backend_finish_dynamic_sections \
5433
          bfin_finish_dynamic_sections
5434
#define elf_backend_gc_mark_hook  bfin_gc_mark_hook
5435
#define bfd_elf32_bfd_merge_private_bfd_data \
5436
          elf32_bfin_merge_private_bfd_data
5437
#define bfd_elf32_bfd_set_private_flags \
5438
          elf32_bfin_set_private_flags
5439
#define bfd_elf32_bfd_print_private_bfd_data \
5440
          elf32_bfin_print_private_bfd_data
5441
#define elf_backend_final_write_processing \
5442
          elf32_bfin_final_write_processing
5443
#define elf_backend_reloc_type_class  elf32_bfin_reloc_type_class
5444
#define elf_backend_stack_align   8
5445
#define elf_backend_can_gc_sections 1
5446
#define elf_backend_special_sections  elf32_bfin_special_sections
5447
#define elf_backend_can_refcount 1
5448
#define elf_backend_want_got_plt 0
5449
#define elf_backend_plt_readonly 1
5450
#define elf_backend_want_plt_sym 0
5451
#define elf_backend_got_header_size 12
5452
#define elf_backend_rela_normal   1
5453
5454
#include "elf32-target.h"
5455
5456
#undef TARGET_LITTLE_SYM
5457
#define TARGET_LITTLE_SYM   bfin_elf32_fdpic_vec
5458
#undef TARGET_LITTLE_NAME
5459
#define TARGET_LITTLE_NAME    "elf32-bfinfdpic"
5460
#undef  elf32_bed
5461
#define elf32_bed     elf32_bfinfdpic_bed
5462
5463
#undef elf_backend_got_header_size
5464
#define elf_backend_got_header_size 0
5465
5466
#undef elf_backend_relocate_section
5467
#define elf_backend_relocate_section  bfinfdpic_relocate_section
5468
#undef elf_backend_check_relocs
5469
#define elf_backend_check_relocs  bfinfdpic_check_relocs
5470
5471
#undef bfd_elf32_bfd_link_hash_table_create
5472
#define bfd_elf32_bfd_link_hash_table_create \
5473
    bfinfdpic_elf_link_hash_table_create
5474
#undef elf_backend_early_size_sections
5475
#define elf_backend_early_size_sections \
5476
    elf32_bfinfdpic_early_size_sections
5477
5478
#undef elf_backend_create_dynamic_sections
5479
#define elf_backend_create_dynamic_sections \
5480
    elf32_bfinfdpic_create_dynamic_sections
5481
#undef elf_backend_adjust_dynamic_symbol
5482
#define elf_backend_adjust_dynamic_symbol \
5483
    elf32_bfinfdpic_adjust_dynamic_symbol
5484
#undef elf_backend_late_size_sections
5485
#define elf_backend_late_size_sections \
5486
    elf32_bfinfdpic_late_size_sections
5487
#undef elf_backend_finish_dynamic_symbol
5488
#define elf_backend_finish_dynamic_symbol \
5489
    elf32_bfinfdpic_finish_dynamic_symbol
5490
#undef elf_backend_finish_dynamic_sections
5491
#define elf_backend_finish_dynamic_sections \
5492
    elf32_bfinfdpic_finish_dynamic_sections
5493
5494
#undef elf_backend_discard_info
5495
#define elf_backend_discard_info \
5496
    bfinfdpic_elf_discard_info
5497
#undef elf_backend_can_make_relative_eh_frame
5498
#define elf_backend_can_make_relative_eh_frame \
5499
    bfinfdpic_elf_use_relative_eh_frame
5500
#undef elf_backend_can_make_lsda_relative_eh_frame
5501
#define elf_backend_can_make_lsda_relative_eh_frame \
5502
    bfinfdpic_elf_use_relative_eh_frame
5503
#undef elf_backend_encode_eh_address
5504
#define elf_backend_encode_eh_address \
5505
    bfinfdpic_elf_encode_eh_address
5506
5507
#undef elf_backend_may_use_rel_p
5508
#define elf_backend_may_use_rel_p 1
5509
#undef elf_backend_may_use_rela_p
5510
#define elf_backend_may_use_rela_p  1
5511
/* We use REL for dynamic relocations only.  */
5512
#undef elf_backend_default_use_rela_p
5513
#define elf_backend_default_use_rela_p  1
5514
5515
#undef elf_backend_omit_section_dynsym
5516
#define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym
5517
5518
#include "elf32-target.h"