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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [bfd/] [elf32-i860.c] - Blame information for rev 205

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
/* Intel i860 specific support for 32-bit ELF.
2
   Copyright 1993, 1995, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
3
   Free Software Foundation, Inc.
4
 
5
   Full i860 support contributed by Jason Eckhardt <jle@cygnus.com>.
6
 
7
   This file is part of BFD, the Binary File Descriptor library.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program; if not, write to the Free Software
21
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22
   MA 02110-1301, USA.  */
23
 
24
#include "sysdep.h"
25
#include "bfd.h"
26
#include "libbfd.h"
27
#include "elf-bfd.h"
28
#include "elf/i860.h"
29
 
30
/* special_function for R_860_PC26 relocation.  */
31
static bfd_reloc_status_type
32
i860_howto_pc26_reloc (bfd *abfd ATTRIBUTE_UNUSED,
33
                       arelent *reloc_entry,
34
                       asymbol *symbol,
35
                       void *data ATTRIBUTE_UNUSED,
36
                       asection *input_section,
37
                       bfd *output_bfd,
38
                       char **error_message ATTRIBUTE_UNUSED)
39
{
40
  bfd_vma insn;
41
  bfd_vma relocation;
42
  bfd_byte *addr;
43
 
44
  if (output_bfd != NULL
45
      && (symbol->flags & BSF_SECTION_SYM) == 0
46
      && (! reloc_entry->howto->partial_inplace
47
          || reloc_entry->addend == 0))
48
    {
49
      reloc_entry->address += input_section->output_offset;
50
      return bfd_reloc_ok;
51
    }
52
 
53
  /* Used elf32-mips.c as an example.  */
54
  if (bfd_is_und_section (symbol->section)
55
      && output_bfd == (bfd *) NULL)
56
    return bfd_reloc_undefined;
57
 
58
  if (bfd_is_com_section (symbol->section))
59
    relocation = 0;
60
  else
61
    relocation = symbol->value;
62
 
63
  relocation += symbol->section->output_section->vma;
64
  relocation += symbol->section->output_offset;
65
  relocation += reloc_entry->addend;
66
 
67
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
68
    return bfd_reloc_outofrange;
69
 
70
  /* Adjust for PC-relative relocation.  */
71
  relocation -= (input_section->output_section->vma
72
                 + input_section->output_offset
73
                 + reloc_entry->address
74
                 + 4);
75
 
76
  /* Check for target out of range.  */
77
  if ((bfd_signed_vma)relocation > (0x3ffffff << 2)
78
      || (bfd_signed_vma)relocation < (-0x4000000 << 2))
79
    return bfd_reloc_outofrange;
80
 
81
  addr = (bfd_byte *) data + reloc_entry->address;
82
  insn = bfd_get_32 (abfd, addr);
83
 
84
  relocation >>= reloc_entry->howto->rightshift;
85
  insn = (insn & ~reloc_entry->howto->dst_mask)
86
         | (relocation & reloc_entry->howto->dst_mask);
87
 
88
  bfd_put_32 (abfd, (bfd_vma) insn, addr);
89
 
90
  return bfd_reloc_ok;
91
}
92
 
93
/* special_function for R_860_PC16 relocation.  */
94
static bfd_reloc_status_type
95
i860_howto_pc16_reloc (bfd *abfd,
96
                       arelent *reloc_entry,
97
                       asymbol *symbol,
98
                       void *data,
99
                       asection *input_section,
100
                       bfd *output_bfd,
101
                       char **error_message ATTRIBUTE_UNUSED)
102
{
103
  bfd_vma insn;
104
  bfd_vma relocation;
105
  bfd_byte *addr;
106
 
107
  if (output_bfd != NULL
108
      && (symbol->flags & BSF_SECTION_SYM) == 0
109
      && (! reloc_entry->howto->partial_inplace
110
          || reloc_entry->addend == 0))
111
    {
112
      reloc_entry->address += input_section->output_offset;
113
      return bfd_reloc_ok;
114
    }
115
 
116
  /* Used elf32-mips.c as an example.  */
117
  if (bfd_is_und_section (symbol->section)
118
      && output_bfd == (bfd *) NULL)
119
    return bfd_reloc_undefined;
120
 
121
  if (bfd_is_com_section (symbol->section))
122
    relocation = 0;
123
  else
124
    relocation = symbol->value;
125
 
126
  relocation += symbol->section->output_section->vma;
127
  relocation += symbol->section->output_offset;
128
  relocation += reloc_entry->addend;
129
 
130
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
131
    return bfd_reloc_outofrange;
132
 
133
  /* Adjust for PC-relative relocation.  */
134
  relocation -= (input_section->output_section->vma
135
                 + input_section->output_offset
136
                 + reloc_entry->address
137
                 + 4);
138
 
139
  /* Check for target out of range.  */
140
  if ((bfd_signed_vma)relocation > (0x7fff << 2)
141
      || (bfd_signed_vma)relocation < (-0x8000 << 2))
142
    return bfd_reloc_outofrange;
143
 
144
  addr = (bfd_byte *) data + reloc_entry->address;
145
  insn = bfd_get_32 (abfd, addr);
146
 
147
  relocation >>= reloc_entry->howto->rightshift;
148
  relocation = (((relocation & 0xf800) << 5) | (relocation & 0x7ff))
149
               & reloc_entry->howto->dst_mask;
150
  insn = (insn & ~reloc_entry->howto->dst_mask) | relocation;
151
 
152
  bfd_put_32 (abfd, (bfd_vma) insn, addr);
153
 
154
  return bfd_reloc_ok;
155
}
156
 
157
/* special_function for R_860_HIGHADJ relocation.  */
158
static bfd_reloc_status_type
159
i860_howto_highadj_reloc (bfd *abfd,
160
                          arelent *reloc_entry,
161
                          asymbol *symbol,
162
                          void *data,
163
                          asection *input_section,
164
                          bfd *output_bfd,
165
                          char **error_message ATTRIBUTE_UNUSED)
166
{
167
  bfd_vma insn;
168
  bfd_vma relocation;
169
  bfd_byte *addr;
170
 
171
  if (output_bfd != NULL
172
      && (symbol->flags & BSF_SECTION_SYM) == 0
173
      && (! reloc_entry->howto->partial_inplace
174
          || reloc_entry->addend == 0))
175
    {
176
      reloc_entry->address += input_section->output_offset;
177
      return bfd_reloc_ok;
178
    }
179
 
180
  /* Used elf32-mips.c as an example.  */
181
  if (bfd_is_und_section (symbol->section)
182
      && output_bfd == (bfd *) NULL)
183
    return bfd_reloc_undefined;
184
 
185
  if (bfd_is_com_section (symbol->section))
186
    relocation = 0;
187
  else
188
    relocation = symbol->value;
189
 
190
  relocation += symbol->section->output_section->vma;
191
  relocation += symbol->section->output_offset;
192
  relocation += reloc_entry->addend;
193
  relocation += 0x8000;
194
 
195
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
196
    return bfd_reloc_outofrange;
197
 
198
  addr = (bfd_byte *) data + reloc_entry->address;
199
  insn = bfd_get_32 (abfd, addr);
200
 
201
  relocation = ((relocation >> 16) & 0xffff);
202
 
203
  insn = (insn & 0xffff0000) | relocation;
204
 
205
  bfd_put_32 (abfd, (bfd_vma) insn, addr);
206
 
207
  return bfd_reloc_ok;
208
}
209
 
210
/* special_function for R_860_SPLITn relocations.  */
211
static bfd_reloc_status_type
212
i860_howto_splitn_reloc (bfd *abfd,
213
                         arelent *reloc_entry,
214
                         asymbol *symbol,
215
                         void *data,
216
                         asection *input_section,
217
                         bfd *output_bfd,
218
                         char **error_message ATTRIBUTE_UNUSED)
219
{
220
  bfd_vma insn;
221
  bfd_vma relocation;
222
  bfd_byte *addr;
223
 
224
  if (output_bfd != NULL
225
      && (symbol->flags & BSF_SECTION_SYM) == 0
226
      && (! reloc_entry->howto->partial_inplace
227
          || reloc_entry->addend == 0))
228
    {
229
      reloc_entry->address += input_section->output_offset;
230
      return bfd_reloc_ok;
231
    }
232
 
233
  /* Used elf32-mips.c as an example.  */
234
  if (bfd_is_und_section (symbol->section)
235
      && output_bfd == (bfd *) NULL)
236
    return bfd_reloc_undefined;
237
 
238
  if (bfd_is_com_section (symbol->section))
239
    relocation = 0;
240
  else
241
    relocation = symbol->value;
242
 
243
  relocation += symbol->section->output_section->vma;
244
  relocation += symbol->section->output_offset;
245
  relocation += reloc_entry->addend;
246
 
247
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
248
    return bfd_reloc_outofrange;
249
 
250
  addr = (bfd_byte *) data + reloc_entry->address;
251
  insn = bfd_get_32 (abfd, addr);
252
 
253
  relocation = (((relocation & 0xf800) << 5) | (relocation & 0x7ff))
254
               & reloc_entry->howto->dst_mask;
255
  insn = (insn & ~reloc_entry->howto->dst_mask) | relocation;
256
 
257
  bfd_put_32 (abfd, (bfd_vma) insn, addr);
258
 
259
  return bfd_reloc_ok;
260
}
261
 
262
/* This howto table is preliminary.  */
263
static reloc_howto_type elf32_i860_howto_table [] =
264
{
265
  /* This relocation does nothing.  */
266
  HOWTO (R_860_NONE,            /* type */
267
         0,                      /* rightshift */
268
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
269
         32,                    /* bitsize */
270
         FALSE,                 /* pc_relative */
271
         0,                      /* bitpos */
272
         complain_overflow_bitfield, /* complain_on_overflow */
273
         bfd_elf_generic_reloc, /* special_function */
274
         "R_860_NONE",          /* name */
275
         FALSE,                 /* partial_inplace */
276
         0,                      /* src_mask */
277
         0,                      /* dst_mask */
278
         FALSE),                /* pcrel_offset */
279
 
280
  /* A 32-bit absolute relocation.  */
281
  HOWTO (R_860_32,              /* type */
282
         0,                      /* rightshift */
283
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
284
         32,                    /* bitsize */
285
         FALSE,                 /* pc_relative */
286
         0,                      /* bitpos */
287
         complain_overflow_bitfield, /* complain_on_overflow */
288
         bfd_elf_generic_reloc, /* special_function */
289
         "R_860_32",            /* name */
290
         FALSE,                 /* partial_inplace */
291
         0xffffffff,            /* src_mask */
292
         0xffffffff,            /* dst_mask */
293
         FALSE),                /* pcrel_offset */
294
 
295
  HOWTO (R_860_COPY,            /* type */
296
         0,                      /* rightshift */
297
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
298
         32,                    /* bitsize */
299
         FALSE,                 /* pc_relative */
300
         0,                      /* bitpos */
301
         complain_overflow_bitfield, /* complain_on_overflow */
302
         bfd_elf_generic_reloc, /* special_function */
303
         "R_860_COPY",          /* name */
304
         TRUE,                  /* partial_inplace */
305
         0xffffffff,            /* src_mask */
306
         0xffffffff,            /* dst_mask */
307
         FALSE),                /* pcrel_offset */
308
 
309
  HOWTO (R_860_GLOB_DAT,        /* type */
310
         0,                      /* rightshift */
311
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
312
         32,                    /* bitsize */
313
         FALSE,                 /* pc_relative */
314
         0,                      /* bitpos */
315
         complain_overflow_bitfield, /* complain_on_overflow */
316
         bfd_elf_generic_reloc, /* special_function */
317
         "R_860_GLOB_DAT",      /* name */
318
         TRUE,                  /* partial_inplace */
319
         0xffffffff,            /* src_mask */
320
         0xffffffff,            /* dst_mask */
321
         FALSE),                /* pcrel_offset */
322
 
323
  HOWTO (R_860_JUMP_SLOT,       /* type */
324
         0,                      /* rightshift */
325
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
326
         32,                    /* bitsize */
327
         FALSE,                 /* pc_relative */
328
         0,                      /* bitpos */
329
         complain_overflow_bitfield, /* complain_on_overflow */
330
         bfd_elf_generic_reloc, /* special_function */
331
         "R_860_JUMP_SLOT",     /* name */
332
         TRUE,                  /* partial_inplace */
333
         0xffffffff,            /* src_mask */
334
         0xffffffff,            /* dst_mask */
335
         FALSE),                /* pcrel_offset */
336
 
337
  HOWTO (R_860_RELATIVE,        /* type */
338
         0,                      /* rightshift */
339
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
340
         32,                    /* bitsize */
341
         FALSE,                 /* pc_relative */
342
         0,                      /* bitpos */
343
         complain_overflow_bitfield, /* complain_on_overflow */
344
         bfd_elf_generic_reloc, /* special_function */
345
         "R_860_RELATIVE",      /* name */
346
         TRUE,                  /* partial_inplace */
347
         0xffffffff,            /* src_mask */
348
         0xffffffff,            /* dst_mask */
349
         FALSE),                /* pcrel_offset */
350
 
351
  /* A 26-bit PC-relative relocation.  */
352
  HOWTO (R_860_PC26,            /* type */
353
         2,                     /* rightshift */
354
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
355
         26,                    /* bitsize */
356
         TRUE,                  /* pc_relative */
357
         0,                      /* bitpos */
358
         complain_overflow_bitfield, /* complain_on_overflow */
359
         i860_howto_pc26_reloc, /* special_function */
360
         "R_860_PC26",          /* name */
361
         FALSE,                 /* partial_inplace */
362
         0x3ffffff,             /* src_mask */
363
         0x3ffffff,             /* dst_mask */
364
         TRUE),                 /* pcrel_offset */
365
 
366
  HOWTO (R_860_PLT26,           /* type */
367
         0,                      /* rightshift */
368
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
369
         26,                    /* bitsize */
370
         TRUE,                  /* pc_relative */
371
         0,                      /* bitpos */
372
         complain_overflow_bitfield, /* complain_on_overflow */
373
         bfd_elf_generic_reloc, /* special_function */
374
         "R_860_PLT26",         /* name */
375
         TRUE,                  /* partial_inplace */
376
         0xffffffff,            /* src_mask */
377
         0xffffffff,            /* dst_mask */
378
         TRUE),                 /* pcrel_offset */
379
 
380
  /* A 16-bit PC-relative relocation.  */
381
  HOWTO (R_860_PC16,            /* type */
382
         2,                     /* rightshift */
383
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
384
         16,                    /* bitsize */
385
         TRUE,                  /* pc_relative */
386
         0,                      /* bitpos */
387
         complain_overflow_bitfield, /* complain_on_overflow */
388
         i860_howto_pc16_reloc, /* special_function */
389
         "R_860_PC16",          /* name */
390
         FALSE,                 /* partial_inplace */
391
         0x1f07ff,              /* src_mask */
392
         0x1f07ff,              /* dst_mask */
393
         TRUE),                 /* pcrel_offset */
394
 
395
  HOWTO (R_860_LOW0,            /* type */
396
         0,                      /* rightshift */
397
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
398
         16,                    /* bitsize */
399
         FALSE,                 /* pc_relative */
400
         0,                      /* bitpos */
401
         complain_overflow_dont, /* complain_on_overflow */
402
         bfd_elf_generic_reloc, /* special_function */
403
         "R_860_LOW0",          /* name */
404
         FALSE,                 /* partial_inplace */
405
         0xffff,                /* src_mask */
406
         0xffff,                /* dst_mask */
407
         FALSE),                /* pcrel_offset */
408
 
409
  HOWTO (R_860_SPLIT0,          /* type */
410
         0,                      /* rightshift */
411
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
412
         16,                    /* bitsize */
413
         FALSE,                 /* pc_relative */
414
         0,                      /* bitpos */
415
         complain_overflow_dont, /* complain_on_overflow */
416
         i860_howto_splitn_reloc, /* special_function */
417
         "R_860_SPLIT0",        /* name */
418
         FALSE,                 /* partial_inplace */
419
         0x1f07ff,              /* src_mask */
420
         0x1f07ff,              /* dst_mask */
421
         FALSE),                /* pcrel_offset */
422
 
423
  HOWTO (R_860_LOW1,            /* type */
424
         0,                      /* rightshift */
425
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
426
         16,                    /* bitsize */
427
         FALSE,                 /* pc_relative */
428
         0,                      /* bitpos */
429
         complain_overflow_dont, /* complain_on_overflow */
430
         bfd_elf_generic_reloc, /* special_function */
431
         "R_860_LOW1",          /* name */
432
         FALSE,                 /* partial_inplace */
433
         0xfffe,                /* src_mask */
434
         0xfffe,                /* dst_mask */
435
         FALSE),                /* pcrel_offset */
436
 
437
  HOWTO (R_860_SPLIT1,          /* type */
438
         0,                      /* rightshift */
439
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
440
         16,                    /* bitsize */
441
         FALSE,                 /* pc_relative */
442
         0,                      /* bitpos */
443
         complain_overflow_dont, /* complain_on_overflow */
444
         i860_howto_splitn_reloc, /* special_function */
445
         "R_860_SPLIT1",        /* name */
446
         FALSE,                 /* partial_inplace */
447
         0x1f07fe,              /* src_mask */
448
         0x1f07fe,              /* dst_mask */
449
         FALSE),                /* pcrel_offset */
450
 
451
  HOWTO (R_860_LOW2,            /* type */
452
         0,                      /* rightshift */
453
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
454
         16,                    /* bitsize */
455
         FALSE,                 /* pc_relative */
456
         0,                      /* bitpos */
457
         complain_overflow_dont, /* complain_on_overflow */
458
         bfd_elf_generic_reloc, /* special_function */
459
         "R_860_LOW2",          /* name */
460
         FALSE,                 /* partial_inplace */
461
         0xfffc,                /* src_mask */
462
         0xfffc,                /* dst_mask */
463
         FALSE),                /* pcrel_offset */
464
 
465
  HOWTO (R_860_SPLIT2,          /* type */
466
         0,                      /* rightshift */
467
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
468
         16,                    /* bitsize */
469
         FALSE,                 /* pc_relative */
470
         0,                      /* bitpos */
471
         complain_overflow_dont, /* complain_on_overflow */
472
         i860_howto_splitn_reloc, /* special_function */
473
         "R_860_SPLIT2",        /* name */
474
         FALSE,                 /* partial_inplace */
475
         0x1f07fc,              /* src_mask */
476
         0x1f07fc,              /* dst_mask */
477
         FALSE),                /* pcrel_offset */
478
 
479
  HOWTO (R_860_LOW3,            /* type */
480
         0,                      /* rightshift */
481
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
482
         16,                    /* bitsize */
483
         FALSE,                 /* pc_relative */
484
         0,                      /* bitpos */
485
         complain_overflow_dont, /* complain_on_overflow */
486
         bfd_elf_generic_reloc, /* special_function */
487
         "R_860_LOW3",          /* name */
488
         FALSE,                 /* partial_inplace */
489
         0xfff8,                /* src_mask */
490
         0xfff8,                /* dst_mask */
491
         FALSE),                /* pcrel_offset */
492
 
493
  HOWTO (R_860_LOGOT0,          /* type */
494
         0,                      /* rightshift */
495
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
496
         16,                    /* bitsize */
497
         FALSE,                 /* pc_relative */
498
         0,                      /* bitpos */
499
         complain_overflow_dont, /* complain_on_overflow */
500
         bfd_elf_generic_reloc, /* special_function */
501
         "R_860_LOGOT0",        /* name */
502
         FALSE,                 /* partial_inplace */
503
         0,                      /* src_mask */
504
         0xffff,                /* dst_mask */
505
         TRUE),                 /* pcrel_offset */
506
 
507
  HOWTO (R_860_SPGOT0,          /* type */
508
         0,                      /* rightshift */
509
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
510
         16,                    /* bitsize */
511
         FALSE,                 /* pc_relative */
512
         0,                      /* bitpos */
513
         complain_overflow_dont, /* complain_on_overflow */
514
         bfd_elf_generic_reloc, /* special_function */
515
         "R_860_SPGOT0",        /* name */
516
         FALSE,                 /* partial_inplace */
517
         0,                      /* src_mask */
518
         0xffff,                /* dst_mask */
519
         TRUE),                 /* pcrel_offset */
520
 
521
  HOWTO (R_860_LOGOT1,          /* type */
522
         0,                      /* rightshift */
523
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
524
         16,                    /* bitsize */
525
         FALSE,                 /* pc_relative */
526
         0,                      /* bitpos */
527
         complain_overflow_dont, /* complain_on_overflow */
528
         bfd_elf_generic_reloc, /* special_function */
529
         "R_860_LOGOT1",        /* name */
530
         FALSE,                 /* partial_inplace */
531
         0,                      /* src_mask */
532
         0xffff,                /* dst_mask */
533
         TRUE),                 /* pcrel_offset */
534
 
535
  HOWTO (R_860_SPGOT1,          /* type */
536
         0,                      /* rightshift */
537
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
538
         16,                    /* bitsize */
539
         FALSE,                 /* pc_relative */
540
         0,                      /* bitpos */
541
         complain_overflow_dont, /* complain_on_overflow */
542
         bfd_elf_generic_reloc, /* special_function */
543
         "R_860_SPGOT1",        /* name */
544
         FALSE,                 /* partial_inplace */
545
         0,                      /* src_mask */
546
         0xffff,                /* dst_mask */
547
         TRUE),                 /* pcrel_offset */
548
 
549
  HOWTO (R_860_LOGOTOFF0,        /* type */
550
         0,                      /* rightshift */
551
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
552
         32,                    /* bitsize */
553
         FALSE,                 /* pc_relative */
554
         0,                      /* bitpos */
555
         complain_overflow_dont, /* complain_on_overflow */
556
         bfd_elf_generic_reloc, /* special_function */
557
         "R_860_LOGOTOFF0",     /* name */
558
         TRUE,                  /* partial_inplace */
559
         0xffffffff,            /* src_mask */
560
         0xffffffff,            /* dst_mask */
561
         FALSE),                /* pcrel_offset */
562
 
563
  HOWTO (R_860_SPGOTOFF0,        /* type */
564
         0,                      /* rightshift */
565
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
566
         32,                    /* bitsize */
567
         FALSE,                 /* pc_relative */
568
         0,                      /* bitpos */
569
         complain_overflow_dont, /* complain_on_overflow */
570
         bfd_elf_generic_reloc, /* special_function */
571
         "R_860_SPGOTOFF0",     /* name */
572
         TRUE,                  /* partial_inplace */
573
         0xffffffff,            /* src_mask */
574
         0xffffffff,            /* dst_mask */
575
         FALSE),                /* pcrel_offset */
576
 
577
  HOWTO (R_860_LOGOTOFF1,        /* type */
578
         0,                      /* rightshift */
579
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
580
         32,                    /* bitsize */
581
         FALSE,                 /* pc_relative */
582
         0,                      /* bitpos */
583
         complain_overflow_dont, /* complain_on_overflow */
584
         bfd_elf_generic_reloc, /* special_function */
585
         "R_860_LOGOTOFF1",     /* name */
586
         TRUE,                  /* partial_inplace */
587
         0xffffffff,            /* src_mask */
588
         0xffffffff,            /* dst_mask */
589
         FALSE),                /* pcrel_offset */
590
 
591
  HOWTO (R_860_SPGOTOFF1,       /* type */
592
         0,                      /* rightshift */
593
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
594
         32,                    /* bitsize */
595
         FALSE,                 /* pc_relative */
596
         0,                      /* bitpos */
597
         complain_overflow_dont, /* complain_on_overflow */
598
         bfd_elf_generic_reloc, /* special_function */
599
         "R_860_SPGOTOFF1",     /* name */
600
         TRUE,                  /* partial_inplace */
601
         0xffffffff,            /* src_mask */
602
         0xffffffff,            /* dst_mask */
603
         FALSE),                /* pcrel_offset */
604
 
605
  HOWTO (R_860_LOGOTOFF2,        /* type */
606
         0,                      /* rightshift */
607
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
608
         32,                    /* bitsize */
609
         FALSE,                 /* pc_relative */
610
         0,                      /* bitpos */
611
         complain_overflow_dont, /* complain_on_overflow */
612
         bfd_elf_generic_reloc, /* special_function */
613
         "R_860_LOGOTOFF2",     /* name */
614
         TRUE,                  /* partial_inplace */
615
         0xffffffff,            /* src_mask */
616
         0xffffffff,            /* dst_mask */
617
         FALSE),                /* pcrel_offset */
618
 
619
  HOWTO (R_860_LOGOTOFF3,        /* type */
620
         0,                      /* rightshift */
621
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
622
         32,                    /* bitsize */
623
         FALSE,                 /* pc_relative */
624
         0,                      /* bitpos */
625
         complain_overflow_dont, /* complain_on_overflow */
626
         bfd_elf_generic_reloc, /* special_function */
627
         "R_860_LOGOTOFF3",     /* name */
628
         TRUE,                  /* partial_inplace */
629
         0xffffffff,            /* src_mask */
630
         0xffffffff,            /* dst_mask */
631
         FALSE),                /* pcrel_offset */
632
 
633
  HOWTO (R_860_LOPC,            /* type */
634
         0,                      /* rightshift */
635
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
636
         16,                    /* bitsize */
637
         TRUE,                  /* pc_relative */
638
         0,                      /* bitpos */
639
         complain_overflow_bitfield, /* complain_on_overflow */
640
         bfd_elf_generic_reloc, /* special_function */
641
         "R_860_LOPC",          /* name */
642
         FALSE,                 /* partial_inplace */
643
         0xffff,                /* src_mask */
644
         0xffff,                /* dst_mask */
645
         TRUE),                 /* pcrel_offset */
646
 
647
  HOWTO (R_860_HIGHADJ,         /* type */
648
         0,                      /* rightshift */
649
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
650
         16,                    /* bitsize */
651
         FALSE,                 /* pc_relative */
652
         0,                      /* bitpos */
653
         complain_overflow_dont, /* complain_on_overflow */
654
         i860_howto_highadj_reloc, /* special_function */
655
         "R_860_HIGHADJ",       /* name */
656
         FALSE,                 /* partial_inplace */
657
         0xffff,                /* src_mask */
658
         0xffff,                /* dst_mask */
659
         FALSE),                /* pcrel_offset */
660
 
661
  HOWTO (R_860_HAGOT,           /* type */
662
         0,                      /* rightshift */
663
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
664
         16,                    /* bitsize */
665
         FALSE,                 /* pc_relative */
666
         0,                      /* bitpos */
667
         complain_overflow_dont, /* complain_on_overflow */
668
         bfd_elf_generic_reloc, /* special_function */
669
         "R_860_HAGOT",         /* name */
670
         FALSE,                 /* partial_inplace */
671
         0,                      /* src_mask */
672
         0xffff,                /* dst_mask */
673
         TRUE),                 /* pcrel_offset */
674
 
675
  HOWTO (R_860_HAGOTOFF,        /* type */
676
         0,                      /* rightshift */
677
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
678
         32,                    /* bitsize */
679
         FALSE,                 /* pc_relative */
680
         0,                      /* bitpos */
681
         complain_overflow_dont, /* complain_on_overflow */
682
         bfd_elf_generic_reloc, /* special_function */
683
         "R_860_HAGOTOFF",      /* name */
684
         TRUE,                  /* partial_inplace */
685
         0xffffffff,            /* src_mask */
686
         0xffffffff,            /* dst_mask */
687
         FALSE),                /* pcrel_offset */
688
 
689
  HOWTO (R_860_HAPC,            /* type */
690
         0,                      /* rightshift */
691
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
692
         16,                    /* bitsize */
693
         TRUE,                  /* pc_relative */
694
         0,                      /* bitpos */
695
         complain_overflow_bitfield, /* complain_on_overflow */
696
         bfd_elf_generic_reloc, /* special_function */
697
         "R_860_HAPC",          /* name */
698
         FALSE,                 /* partial_inplace */
699
         0xffff,                /* src_mask */
700
         0xffff,                /* dst_mask */
701
         TRUE),                 /* pcrel_offset */
702
 
703
  HOWTO (R_860_HIGH,            /* type */
704
         16,                    /* rightshift */
705
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
706
         16,                    /* bitsize */
707
         FALSE,                 /* pc_relative */
708
         0,                      /* bitpos */
709
         complain_overflow_dont, /* complain_on_overflow */
710
         bfd_elf_generic_reloc, /* special_function */
711
         "R_860_HIGH",          /* name */
712
         FALSE,                 /* partial_inplace */
713
         0xffff,                /* src_mask */
714
         0xffff,                /* dst_mask */
715
         FALSE),                /* pcrel_offset */
716
 
717
  HOWTO (R_860_HIGOT,           /* type */
718
         0,                      /* rightshift */
719
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
720
         16,                    /* bitsize */
721
         FALSE,                 /* pc_relative */
722
         0,                      /* bitpos */
723
         complain_overflow_dont, /* complain_on_overflow */
724
         bfd_elf_generic_reloc, /* special_function */
725
         "R_860_HIGOT",         /* name */
726
         FALSE,                 /* partial_inplace */
727
         0,                      /* src_mask */
728
         0xffff,                /* dst_mask */
729
         TRUE),                 /* pcrel_offset */
730
 
731
  HOWTO (R_860_HIGOTOFF,        /* type */
732
         0,                      /* rightshift */
733
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
734
         32,                    /* bitsize */
735
         FALSE,                 /* pc_relative */
736
         0,                      /* bitpos */
737
         complain_overflow_dont, /* complain_on_overflow */
738
         bfd_elf_generic_reloc, /* special_function */
739
         "R_860_HIGOTOFF",      /* name */
740
         TRUE,                  /* partial_inplace */
741
         0xffffffff,            /* src_mask */
742
         0xffffffff,            /* dst_mask */
743
         FALSE),                /* pcrel_offset */
744
};
745
 
746
static unsigned char elf_code_to_howto_index[R_860_max + 1];
747
 
748
static reloc_howto_type *
749
lookup_howto (unsigned int rtype)
750
{
751
  static int initialized = 0;
752
  int i;
753
  int howto_tbl_size = (int) (sizeof (elf32_i860_howto_table)
754
                        / sizeof (elf32_i860_howto_table[0]));
755
 
756
  if (! initialized)
757
    {
758
      initialized = 1;
759
      memset (elf_code_to_howto_index, 0xff,
760
              sizeof (elf_code_to_howto_index));
761
      for (i = 0; i < howto_tbl_size; i++)
762
        elf_code_to_howto_index[elf32_i860_howto_table[i].type] = i;
763
    }
764
 
765
  BFD_ASSERT (rtype <= R_860_max);
766
  i = elf_code_to_howto_index[rtype];
767
  if (i >= howto_tbl_size)
768
    return 0;
769
  return elf32_i860_howto_table + i;
770
}
771
 
772
/* Given a BFD reloc, return the matching HOWTO structure.  */
773
static reloc_howto_type *
774
elf32_i860_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
775
                              bfd_reloc_code_real_type code)
776
{
777
  unsigned int rtype;
778
 
779
  switch (code)
780
    {
781
    case BFD_RELOC_NONE:
782
      rtype = R_860_NONE;
783
      break;
784
    case BFD_RELOC_32:
785
      rtype = R_860_32;
786
      break;
787
    case BFD_RELOC_860_COPY:
788
      rtype = R_860_COPY;
789
      break;
790
    case BFD_RELOC_860_GLOB_DAT:
791
      rtype = R_860_GLOB_DAT;
792
      break;
793
    case BFD_RELOC_860_JUMP_SLOT:
794
      rtype = R_860_JUMP_SLOT;
795
      break;
796
    case BFD_RELOC_860_RELATIVE:
797
      rtype = R_860_RELATIVE;
798
      break;
799
    case BFD_RELOC_860_PC26:
800
      rtype = R_860_PC26;
801
      break;
802
    case BFD_RELOC_860_PLT26:
803
      rtype = R_860_PLT26;
804
      break;
805
    case BFD_RELOC_860_PC16:
806
      rtype = R_860_PC16;
807
      break;
808
    case BFD_RELOC_860_LOW0:
809
      rtype = R_860_LOW0;
810
      break;
811
    case BFD_RELOC_860_SPLIT0:
812
      rtype = R_860_SPLIT0;
813
      break;
814
    case BFD_RELOC_860_LOW1:
815
      rtype = R_860_LOW1;
816
      break;
817
    case BFD_RELOC_860_SPLIT1:
818
      rtype = R_860_SPLIT1;
819
      break;
820
    case BFD_RELOC_860_LOW2:
821
      rtype = R_860_LOW2;
822
      break;
823
    case BFD_RELOC_860_SPLIT2:
824
      rtype = R_860_SPLIT2;
825
      break;
826
    case BFD_RELOC_860_LOW3:
827
      rtype = R_860_LOW3;
828
      break;
829
    case BFD_RELOC_860_LOGOT0:
830
      rtype = R_860_LOGOT0;
831
      break;
832
    case BFD_RELOC_860_SPGOT0:
833
      rtype = R_860_SPGOT0;
834
      break;
835
    case BFD_RELOC_860_LOGOT1:
836
      rtype = R_860_LOGOT1;
837
      break;
838
    case BFD_RELOC_860_SPGOT1:
839
      rtype = R_860_SPGOT1;
840
      break;
841
    case BFD_RELOC_860_LOGOTOFF0:
842
      rtype = R_860_LOGOTOFF0;
843
      break;
844
    case BFD_RELOC_860_SPGOTOFF0:
845
      rtype = R_860_SPGOTOFF0;
846
      break;
847
    case BFD_RELOC_860_LOGOTOFF1:
848
      rtype = R_860_LOGOTOFF1;
849
      break;
850
    case BFD_RELOC_860_SPGOTOFF1:
851
      rtype = R_860_SPGOTOFF1;
852
      break;
853
    case BFD_RELOC_860_LOGOTOFF2:
854
      rtype = R_860_LOGOTOFF2;
855
      break;
856
    case BFD_RELOC_860_LOGOTOFF3:
857
      rtype = R_860_LOGOTOFF3;
858
      break;
859
    case BFD_RELOC_860_LOPC:
860
      rtype = R_860_LOPC;
861
      break;
862
    case BFD_RELOC_860_HIGHADJ:
863
      rtype = R_860_HIGHADJ;
864
      break;
865
    case BFD_RELOC_860_HAGOT:
866
      rtype = R_860_HAGOT;
867
      break;
868
    case BFD_RELOC_860_HAGOTOFF:
869
      rtype = R_860_HAGOTOFF;
870
      break;
871
    case BFD_RELOC_860_HAPC:
872
      rtype = R_860_HAPC;
873
      break;
874
    case BFD_RELOC_860_HIGH:
875
      rtype = R_860_HIGH;
876
      break;
877
    case BFD_RELOC_860_HIGOT:
878
      rtype = R_860_HIGOT;
879
      break;
880
    case BFD_RELOC_860_HIGOTOFF:
881
      rtype = R_860_HIGOTOFF;
882
      break;
883
    default:
884
      rtype = 0;
885
      break;
886
    }
887
  return lookup_howto (rtype);
888
}
889
 
890
static reloc_howto_type *
891
elf32_i860_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
892
                              const char *r_name)
893
{
894
  unsigned int i;
895
 
896
  for (i = 0;
897
       i < (sizeof (elf32_i860_howto_table)
898
            / sizeof (elf32_i860_howto_table[0]));
899
       i++)
900
    if (elf32_i860_howto_table[i].name != NULL
901
        && strcasecmp (elf32_i860_howto_table[i].name, r_name) == 0)
902
      return &elf32_i860_howto_table[i];
903
 
904
  return NULL;
905
}
906
 
907
/* Given a ELF reloc, return the matching HOWTO structure.  */
908
static void
909
elf32_i860_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
910
                               arelent *bfd_reloc,
911
                               Elf_Internal_Rela *elf_reloc)
912
{
913
  bfd_reloc->howto
914
    = lookup_howto ((unsigned) ELF32_R_TYPE (elf_reloc->r_info));
915
}
916
 
917
/* Specialized relocation handler for R_860_SPLITn.  These relocations
918
   involves a 16-bit field that is split into two contiguous parts.  */
919
static bfd_reloc_status_type
920
elf32_i860_relocate_splitn (bfd *input_bfd,
921
                            Elf_Internal_Rela *rello,
922
                            bfd_byte *contents,
923
                            bfd_vma value)
924
{
925
  bfd_vma insn;
926
  reloc_howto_type *howto;
927
  howto = lookup_howto ((unsigned) ELF32_R_TYPE (rello->r_info));
928
  insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
929
 
930
  /* Relocate.  */
931
  value += rello->r_addend;
932
 
933
  /* Separate the fields and insert.  */
934
  value = (((value & 0xf800) << 5) | (value & 0x7ff)) & howto->dst_mask;
935
  insn = (insn & ~howto->dst_mask) | value;
936
 
937
  bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
938
  return bfd_reloc_ok;
939
}
940
 
941
/* Specialized relocation handler for R_860_PC16.  This relocation
942
   involves a 16-bit, PC-relative field that is split into two contiguous
943
   parts.  */
944
static bfd_reloc_status_type
945
elf32_i860_relocate_pc16 (bfd *input_bfd,
946
                          asection *input_section,
947
                          Elf_Internal_Rela *rello,
948
                          bfd_byte *contents,
949
                          bfd_vma value)
950
{
951
  bfd_vma insn;
952
  reloc_howto_type *howto;
953
  howto = lookup_howto ((unsigned) ELF32_R_TYPE (rello->r_info));
954
  insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
955
 
956
  /* Adjust for PC-relative relocation.  */
957
  value -= (input_section->output_section->vma
958
            + input_section->output_offset);
959
  value -= rello->r_offset;
960
 
961
  /* Relocate.  */
962
  value += rello->r_addend;
963
 
964
  /* Adjust the value by 4, then separate the fields and insert.  */
965
  value = (value - 4) >> howto->rightshift;
966
  value = (((value & 0xf800) << 5) | (value & 0x7ff)) & howto->dst_mask;
967
  insn = (insn & ~howto->dst_mask) | value;
968
 
969
  bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
970
  return bfd_reloc_ok;
971
 
972
}
973
 
974
/* Specialized relocation handler for R_860_PC26.  This relocation
975
   involves a 26-bit, PC-relative field which must be adjusted by 4.  */
976
static bfd_reloc_status_type
977
elf32_i860_relocate_pc26 (bfd *input_bfd,
978
                          asection *input_section,
979
                          Elf_Internal_Rela *rello,
980
                          bfd_byte *contents,
981
                          bfd_vma value)
982
{
983
  bfd_vma insn;
984
  reloc_howto_type *howto;
985
  howto = lookup_howto ((unsigned) ELF32_R_TYPE (rello->r_info));
986
  insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
987
 
988
  /* Adjust for PC-relative relocation.  */
989
  value -= (input_section->output_section->vma
990
            + input_section->output_offset);
991
  value -= rello->r_offset;
992
 
993
  /* Relocate.  */
994
  value += rello->r_addend;
995
 
996
  /* Adjust value by 4 and insert the field.  */
997
  value = ((value - 4) >> howto->rightshift) & howto->dst_mask;
998
  insn = (insn & ~howto->dst_mask) | value;
999
 
1000
  bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
1001
  return bfd_reloc_ok;
1002
 
1003
}
1004
 
1005
/* Specialized relocation handler for R_860_HIGHADJ.  */
1006
static bfd_reloc_status_type
1007
elf32_i860_relocate_highadj (bfd *input_bfd,
1008
                             Elf_Internal_Rela *rel,
1009
                             bfd_byte *contents,
1010
                             bfd_vma value)
1011
{
1012
  bfd_vma insn;
1013
 
1014
  insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
1015
 
1016
  value += rel->r_addend;
1017
  value += 0x8000;
1018
  value = ((value >> 16) & 0xffff);
1019
 
1020
  insn = (insn & 0xffff0000) | value;
1021
 
1022
  bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
1023
  return bfd_reloc_ok;
1024
}
1025
 
1026
/* Perform a single relocation.  By default we use the standard BFD
1027
   routines. However, we handle some specially.  */
1028
static bfd_reloc_status_type
1029
i860_final_link_relocate (reloc_howto_type *howto,
1030
                          bfd *input_bfd,
1031
                          asection *input_section,
1032
                          bfd_byte *contents,
1033
                          Elf_Internal_Rela *rel,
1034
                          bfd_vma relocation)
1035
{
1036
  return _bfd_final_link_relocate (howto, input_bfd, input_section,
1037
                                   contents, rel->r_offset, relocation,
1038
                                   rel->r_addend);
1039
}
1040
 
1041
/* Relocate an i860 ELF section.
1042
 
1043
   This is boiler-plate code copied from fr30.
1044
 
1045
   The RELOCATE_SECTION function is called by the new ELF backend linker
1046
   to handle the relocations for a section.
1047
 
1048
   The relocs are always passed as Rela structures; if the section
1049
   actually uses Rel structures, the r_addend field will always be
1050
   zero.
1051
 
1052
   This function is responsible for adjusting the section contents as
1053
   necessary, and (if using Rela relocs and generating a relocatable
1054
   output file) adjusting the reloc addend as necessary.
1055
 
1056
   This function does not have to worry about setting the reloc
1057
   address or the reloc symbol index.
1058
 
1059
   LOCAL_SYMS is a pointer to the swapped in local symbols.
1060
 
1061
   LOCAL_SECTIONS is an array giving the section in the input file
1062
   corresponding to the st_shndx field of each local symbol.
1063
 
1064
   The global hash table entry for the global symbols can be found
1065
   via elf_sym_hashes (input_bfd).
1066
 
1067
   When generating relocatable output, this function must handle
1068
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
1069
   going to be the section symbol corresponding to the output
1070
   section, which means that the addend must be adjusted
1071
   accordingly.  */
1072
static bfd_boolean
1073
elf32_i860_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1074
                             struct bfd_link_info *info,
1075
                             bfd *input_bfd,
1076
                             asection *input_section,
1077
                             bfd_byte *contents,
1078
                             Elf_Internal_Rela *relocs,
1079
                             Elf_Internal_Sym *local_syms,
1080
                             asection **local_sections)
1081
{
1082
  Elf_Internal_Shdr *symtab_hdr;
1083
  struct elf_link_hash_entry **sym_hashes;
1084
  Elf_Internal_Rela *rel;
1085
  Elf_Internal_Rela *relend;
1086
 
1087
  symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1088
  sym_hashes = elf_sym_hashes (input_bfd);
1089
  relend     = relocs + input_section->reloc_count;
1090
 
1091
  for (rel = relocs; rel < relend; rel ++)
1092
    {
1093
      reloc_howto_type *           howto;
1094
      unsigned long                r_symndx;
1095
      Elf_Internal_Sym *           sym;
1096
      asection *                   sec;
1097
      struct elf_link_hash_entry * h;
1098
      bfd_vma                      relocation;
1099
      bfd_reloc_status_type        r;
1100
      const char *                 name = NULL;
1101
      int                          r_type;
1102
 
1103
      r_type = ELF32_R_TYPE (rel->r_info);
1104
      r_symndx = ELF32_R_SYM (rel->r_info);
1105
 
1106
      howto = lookup_howto ((unsigned) ELF32_R_TYPE (rel->r_info));
1107
      h     = NULL;
1108
      sym   = NULL;
1109
      sec   = NULL;
1110
 
1111
      if (r_symndx < symtab_hdr->sh_info)
1112
        {
1113
          sym = local_syms + r_symndx;
1114
          sec = local_sections [r_symndx];
1115
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1116
 
1117
          name = bfd_elf_string_from_elf_section
1118
            (input_bfd, symtab_hdr->sh_link, sym->st_name);
1119
          name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1120
        }
1121
      else
1122
        {
1123
          bfd_boolean unresolved_reloc, warned;
1124
 
1125
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1126
                                   r_symndx, symtab_hdr, sym_hashes,
1127
                                   h, sec, relocation,
1128
                                   unresolved_reloc, warned);
1129
        }
1130
 
1131
      if (sec != NULL && elf_discarded_section (sec))
1132
        {
1133
          /* For relocs against symbols from removed linkonce sections,
1134
             or sections discarded by a linker script, we just want the
1135
             section contents zeroed.  Avoid any special processing.  */
1136
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1137
          rel->r_info = 0;
1138
          rel->r_addend = 0;
1139
          continue;
1140
        }
1141
 
1142
      if (info->relocatable)
1143
        continue;
1144
 
1145
      switch (r_type)
1146
        {
1147
        default:
1148
          r = i860_final_link_relocate (howto, input_bfd, input_section,
1149
                                        contents, rel, relocation);
1150
          break;
1151
 
1152
        case R_860_HIGHADJ:
1153
          r = elf32_i860_relocate_highadj (input_bfd, rel, contents,
1154
                                           relocation);
1155
          break;
1156
 
1157
        case R_860_PC16:
1158
          r = elf32_i860_relocate_pc16 (input_bfd, input_section, rel,
1159
                                        contents, relocation);
1160
          break;
1161
 
1162
        case R_860_PC26:
1163
          r = elf32_i860_relocate_pc26 (input_bfd, input_section, rel,
1164
                                        contents, relocation);
1165
          break;
1166
 
1167
        case R_860_SPLIT0:
1168
        case R_860_SPLIT1:
1169
        case R_860_SPLIT2:
1170
          r = elf32_i860_relocate_splitn (input_bfd, rel, contents,
1171
                                          relocation);
1172
          break;
1173
 
1174
        /* We do not yet handle GOT/PLT/Dynamic relocations.  */
1175
        case R_860_COPY:
1176
        case R_860_GLOB_DAT:
1177
        case R_860_JUMP_SLOT:
1178
        case R_860_RELATIVE:
1179
        case R_860_PLT26:
1180
        case R_860_LOGOT0:
1181
        case R_860_SPGOT0:
1182
        case R_860_LOGOT1:
1183
        case R_860_SPGOT1:
1184
        case R_860_LOGOTOFF0:
1185
        case R_860_SPGOTOFF0:
1186
        case R_860_LOGOTOFF1:
1187
        case R_860_SPGOTOFF1:
1188
        case R_860_LOGOTOFF2:
1189
        case R_860_LOGOTOFF3:
1190
        case R_860_LOPC:
1191
        case R_860_HAGOT:
1192
        case R_860_HAGOTOFF:
1193
        case R_860_HAPC:
1194
        case R_860_HIGOT:
1195
        case R_860_HIGOTOFF:
1196
          r = bfd_reloc_notsupported;
1197
          break;
1198
        }
1199
 
1200
      if (r != bfd_reloc_ok)
1201
        {
1202
          const char * msg = (const char *) NULL;
1203
 
1204
          switch (r)
1205
            {
1206
            case bfd_reloc_overflow:
1207
              r = info->callbacks->reloc_overflow
1208
                (info, (h ? &h->root : NULL), name, howto->name,
1209
                 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1210
              break;
1211
 
1212
            case bfd_reloc_undefined:
1213
              r = info->callbacks->undefined_symbol
1214
                (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1215
              break;
1216
 
1217
            case bfd_reloc_outofrange:
1218
              msg = _("internal error: out of range error");
1219
              break;
1220
 
1221
            case bfd_reloc_notsupported:
1222
              msg = _("internal error: unsupported relocation error");
1223
              break;
1224
 
1225
            case bfd_reloc_dangerous:
1226
              msg = _("internal error: dangerous relocation");
1227
              break;
1228
 
1229
            default:
1230
              msg = _("internal error: unknown error");
1231
              break;
1232
            }
1233
 
1234
          if (msg)
1235
            r = info->callbacks->warning
1236
              (info, msg, name, input_bfd, input_section, rel->r_offset);
1237
 
1238
          if (! r)
1239
            return FALSE;
1240
        }
1241
    }
1242
 
1243
  return TRUE;
1244
}
1245
 
1246
/* Return whether a symbol name implies a local label.  SVR4/860 compilers
1247
   generate labels of the form ".ep.function_name" to denote the end of a
1248
   function prolog. These should be local.
1249
   ??? Do any other SVR4 compilers have this convention? If so, this should
1250
   be added to the generic routine.  */
1251
static bfd_boolean
1252
elf32_i860_is_local_label_name (bfd *abfd, const char *name)
1253
{
1254
  if (name[0] == '.' && name[1] == 'e' && name[2] == 'p' && name[3] == '.')
1255
    return TRUE;
1256
 
1257
  return _bfd_elf_is_local_label_name (abfd, name);
1258
}
1259
 
1260
#define TARGET_BIG_SYM          bfd_elf32_i860_vec
1261
#define TARGET_BIG_NAME         "elf32-i860"
1262
#define TARGET_LITTLE_SYM       bfd_elf32_i860_little_vec
1263
#define TARGET_LITTLE_NAME      "elf32-i860-little"
1264
#define ELF_ARCH                bfd_arch_i860
1265
#define ELF_MACHINE_CODE        EM_860
1266
#define ELF_MAXPAGESIZE         4096
1267
 
1268
#define elf_backend_rela_normal                 1
1269
#define elf_info_to_howto_rel                   NULL
1270
#define elf_info_to_howto                       elf32_i860_info_to_howto_rela
1271
#define elf_backend_relocate_section            elf32_i860_relocate_section
1272
#define bfd_elf32_bfd_reloc_type_lookup         elf32_i860_reloc_type_lookup
1273
#define bfd_elf32_bfd_reloc_name_lookup elf32_i860_reloc_name_lookup
1274
#define bfd_elf32_bfd_is_local_label_name       elf32_i860_is_local_label_name
1275
 
1276
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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