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

Subversion Repositories open8_urisc

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

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

Line No. Rev Author Line
1 14 khays
/* 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
        RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1133
                                         rel, relend, howto, contents);
1134
 
1135
      if (info->relocatable)
1136
        continue;
1137
 
1138
      switch (r_type)
1139
        {
1140
        default:
1141
          r = i860_final_link_relocate (howto, input_bfd, input_section,
1142
                                        contents, rel, relocation);
1143
          break;
1144
 
1145
        case R_860_HIGHADJ:
1146
          r = elf32_i860_relocate_highadj (input_bfd, rel, contents,
1147
                                           relocation);
1148
          break;
1149
 
1150
        case R_860_PC16:
1151
          r = elf32_i860_relocate_pc16 (input_bfd, input_section, rel,
1152
                                        contents, relocation);
1153
          break;
1154
 
1155
        case R_860_PC26:
1156
          r = elf32_i860_relocate_pc26 (input_bfd, input_section, rel,
1157
                                        contents, relocation);
1158
          break;
1159
 
1160
        case R_860_SPLIT0:
1161
        case R_860_SPLIT1:
1162
        case R_860_SPLIT2:
1163
          r = elf32_i860_relocate_splitn (input_bfd, rel, contents,
1164
                                          relocation);
1165
          break;
1166
 
1167
        /* We do not yet handle GOT/PLT/Dynamic relocations.  */
1168
        case R_860_COPY:
1169
        case R_860_GLOB_DAT:
1170
        case R_860_JUMP_SLOT:
1171
        case R_860_RELATIVE:
1172
        case R_860_PLT26:
1173
        case R_860_LOGOT0:
1174
        case R_860_SPGOT0:
1175
        case R_860_LOGOT1:
1176
        case R_860_SPGOT1:
1177
        case R_860_LOGOTOFF0:
1178
        case R_860_SPGOTOFF0:
1179
        case R_860_LOGOTOFF1:
1180
        case R_860_SPGOTOFF1:
1181
        case R_860_LOGOTOFF2:
1182
        case R_860_LOGOTOFF3:
1183
        case R_860_LOPC:
1184
        case R_860_HAGOT:
1185
        case R_860_HAGOTOFF:
1186
        case R_860_HAPC:
1187
        case R_860_HIGOT:
1188
        case R_860_HIGOTOFF:
1189
          r = bfd_reloc_notsupported;
1190
          break;
1191
        }
1192
 
1193
      if (r != bfd_reloc_ok)
1194
        {
1195
          const char * msg = (const char *) NULL;
1196
 
1197
          switch (r)
1198
            {
1199
            case bfd_reloc_overflow:
1200
              r = info->callbacks->reloc_overflow
1201
                (info, (h ? &h->root : NULL), name, howto->name,
1202
                 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1203
              break;
1204
 
1205
            case bfd_reloc_undefined:
1206
              r = info->callbacks->undefined_symbol
1207
                (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1208
              break;
1209
 
1210
            case bfd_reloc_outofrange:
1211
              msg = _("internal error: out of range error");
1212
              break;
1213
 
1214
            case bfd_reloc_notsupported:
1215
              msg = _("internal error: unsupported relocation error");
1216
              break;
1217
 
1218
            case bfd_reloc_dangerous:
1219
              msg = _("internal error: dangerous relocation");
1220
              break;
1221
 
1222
            default:
1223
              msg = _("internal error: unknown error");
1224
              break;
1225
            }
1226
 
1227
          if (msg)
1228
            r = info->callbacks->warning
1229
              (info, msg, name, input_bfd, input_section, rel->r_offset);
1230
 
1231
          if (! r)
1232
            return FALSE;
1233
        }
1234
    }
1235
 
1236
  return TRUE;
1237
}
1238
 
1239
/* Return whether a symbol name implies a local label.  SVR4/860 compilers
1240
   generate labels of the form ".ep.function_name" to denote the end of a
1241
   function prolog. These should be local.
1242
   ??? Do any other SVR4 compilers have this convention? If so, this should
1243
   be added to the generic routine.  */
1244
static bfd_boolean
1245
elf32_i860_is_local_label_name (bfd *abfd, const char *name)
1246
{
1247
  if (name[0] == '.' && name[1] == 'e' && name[2] == 'p' && name[3] == '.')
1248
    return TRUE;
1249
 
1250
  return _bfd_elf_is_local_label_name (abfd, name);
1251
}
1252
 
1253
#define TARGET_BIG_SYM          bfd_elf32_i860_vec
1254
#define TARGET_BIG_NAME         "elf32-i860"
1255
#define TARGET_LITTLE_SYM       bfd_elf32_i860_little_vec
1256
#define TARGET_LITTLE_NAME      "elf32-i860-little"
1257
#define ELF_ARCH                bfd_arch_i860
1258
#define ELF_MACHINE_CODE        EM_860
1259
#define ELF_MAXPAGESIZE         4096
1260
 
1261
#define elf_backend_rela_normal                 1
1262
#define elf_info_to_howto_rel                   NULL
1263
#define elf_info_to_howto                       elf32_i860_info_to_howto_rela
1264
#define elf_backend_relocate_section            elf32_i860_relocate_section
1265
#define bfd_elf32_bfd_reloc_type_lookup         elf32_i860_reloc_type_lookup
1266
#define bfd_elf32_bfd_reloc_name_lookup elf32_i860_reloc_name_lookup
1267
#define bfd_elf32_bfd_is_local_label_name       elf32_i860_is_local_label_name
1268
 
1269
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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