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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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