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

Subversion Repositories open8_urisc

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

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

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