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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [bfd/] [elf32-bfin.c] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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