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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [bfd/] [elf32-bfin.c] - Blame information for rev 841

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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