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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [bfd/] [elf32-cr16c.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* BFD back-end for National Semiconductor's CR16C ELF
2
   Copyright 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
3
 
4
   This file is part of BFD, the Binary File Descriptor library.
5
 
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 3 of the License, or
9
   (at your option) any later version.
10
 
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19
   MA 02110-1301, USA.  */
20
 
21
#include "sysdep.h"
22
#include "bfd.h"
23
#include "libbfd.h"
24
#include "bfdlink.h"
25
#include "elf/cr16c.h"
26
#include "elf-bfd.h"
27
 
28
 
29
#define USE_REL 1       /* CR16C uses REL relocations instead of RELA.  */
30
 
31
/* The following definition is based on EMPTY_HOWTO macro,
32
   but also initiates the "name" field in HOWTO struct.  */
33
#define ONLY_NAME_HOWTO(C) \
34
  HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \
35
          STRINGX(C), FALSE, 0, 0, FALSE)
36
 
37
/* reloc_map_index array maps CRASM relocation type into a BFD
38
   relocation enum. The array's indices are synchronized with
39
   RINDEX_16C_* indices, created in include/elf/cr16c.h.
40
   The array is used in:
41
   1. elf32-cr16c.c : elf_cr16c_reloc_type_lookup().
42
   2. asreloc.c : find_reloc_type(). */
43
 
44
RELOC_MAP reloc_map_index[RINDEX_16C_MAX] =
45
{
46
  {R_16C_NUM08,     BFD_RELOC_16C_NUM08},
47
  {R_16C_NUM08_C,   BFD_RELOC_16C_NUM08_C},
48
  {R_16C_NUM16,     BFD_RELOC_16C_NUM16},
49
  {R_16C_NUM16_C,   BFD_RELOC_16C_NUM16_C},
50
  {R_16C_NUM32,     BFD_RELOC_16C_NUM32},
51
  {R_16C_NUM32_C,   BFD_RELOC_16C_NUM32_C},
52
  {R_16C_DISP04,    BFD_RELOC_16C_DISP04},
53
  {R_16C_DISP04_C,  BFD_RELOC_16C_DISP04_C},
54
  {R_16C_DISP08,    BFD_RELOC_16C_DISP08},
55
  {R_16C_DISP08_C,  BFD_RELOC_16C_DISP08_C},
56
  {R_16C_DISP16,    BFD_RELOC_16C_DISP16},
57
  {R_16C_DISP16_C,  BFD_RELOC_16C_DISP16_C},
58
  {R_16C_DISP24,    BFD_RELOC_16C_DISP24},
59
  {R_16C_DISP24_C,  BFD_RELOC_16C_DISP24_C},
60
  {R_16C_DISP24a,   BFD_RELOC_16C_DISP24a},
61
  {R_16C_DISP24a_C, BFD_RELOC_16C_DISP24a_C},
62
  {R_16C_REG04,     BFD_RELOC_16C_REG04},
63
  {R_16C_REG04_C,   BFD_RELOC_16C_REG04_C},
64
  {R_16C_REG04a,    BFD_RELOC_16C_REG04a},
65
  {R_16C_REG04a_C,  BFD_RELOC_16C_REG04a_C},
66
  {R_16C_REG14,     BFD_RELOC_16C_REG14},
67
  {R_16C_REG14_C,   BFD_RELOC_16C_REG14_C},
68
  {R_16C_REG16,     BFD_RELOC_16C_REG16},
69
  {R_16C_REG16_C,   BFD_RELOC_16C_REG16_C},
70
  {R_16C_REG20,     BFD_RELOC_16C_REG20},
71
  {R_16C_REG20_C,   BFD_RELOC_16C_REG20_C},
72
  {R_16C_ABS20,     BFD_RELOC_16C_ABS20},
73
  {R_16C_ABS20_C,   BFD_RELOC_16C_ABS20_C},
74
  {R_16C_ABS24,     BFD_RELOC_16C_ABS24},
75
  {R_16C_ABS24_C,   BFD_RELOC_16C_ABS24_C},
76
  {R_16C_IMM04,     BFD_RELOC_16C_IMM04},
77
  {R_16C_IMM04_C,   BFD_RELOC_16C_IMM04_C},
78
  {R_16C_IMM16,     BFD_RELOC_16C_IMM16},
79
  {R_16C_IMM16_C,   BFD_RELOC_16C_IMM16_C},
80
  {R_16C_IMM20,     BFD_RELOC_16C_IMM20},
81
  {R_16C_IMM20_C,   BFD_RELOC_16C_IMM20_C},
82
  {R_16C_IMM24,     BFD_RELOC_16C_IMM24},
83
  {R_16C_IMM24_C,   BFD_RELOC_16C_IMM24_C},
84
  {R_16C_IMM32,     BFD_RELOC_16C_IMM32},
85
  {R_16C_IMM32_C,   BFD_RELOC_16C_IMM32_C}
86
};
87
 
88
static reloc_howto_type elf_howto_table[] =
89
{
90
  /* 00 */ ONLY_NAME_HOWTO (RINDEX_16C_NUM08),
91
  /* 01 */ ONLY_NAME_HOWTO (RINDEX_16C_NUM08_C),
92
  /* 02 */ ONLY_NAME_HOWTO (RINDEX_16C_NUM16),
93
  /* 03 */ ONLY_NAME_HOWTO (RINDEX_16C_NUM16_C),
94
  /* 04 */ ONLY_NAME_HOWTO (RINDEX_16C_NUM32),
95
  /* 05 */ ONLY_NAME_HOWTO (RINDEX_16C_NUM32_C),
96
  /* 06 */ ONLY_NAME_HOWTO (RINDEX_16C_DISP04),
97
  /* 07 */ ONLY_NAME_HOWTO (RINDEX_16C_DISP04_C),
98
  /* 08 */ ONLY_NAME_HOWTO (RINDEX_16C_DISP08),
99
  /* 09 */ ONLY_NAME_HOWTO (RINDEX_16C_DISP08_C),
100
  /* 10 */ ONLY_NAME_HOWTO (RINDEX_16C_DISP16),
101
  /* 11 */ ONLY_NAME_HOWTO (RINDEX_16C_DISP16_C),
102
  /* 12 */ ONLY_NAME_HOWTO (RINDEX_16C_DISP24),
103
  /* 13 */ ONLY_NAME_HOWTO (RINDEX_16C_DISP24_C),
104
  /* 14 */ ONLY_NAME_HOWTO (RINDEX_16C_DISP24a),
105
  /* 15 */ ONLY_NAME_HOWTO (RINDEX_16C_DISP24a_C),
106
  /* 16 */ ONLY_NAME_HOWTO (RINDEX_16C_REG04),
107
  /* 17 */ ONLY_NAME_HOWTO (RINDEX_16C_REG04_C),
108
  /* 18 */ ONLY_NAME_HOWTO (RINDEX_16C_REG04a),
109
  /* 19 */ ONLY_NAME_HOWTO (RINDEX_16C_REG04a_C),
110
  /* 20 */ ONLY_NAME_HOWTO (RINDEX_16C_REG14),
111
  /* 21 */ ONLY_NAME_HOWTO (RINDEX_16C_REG14_C),
112
  /* 22 */ ONLY_NAME_HOWTO (RINDEX_16C_REG16),
113
  /* 23 */ ONLY_NAME_HOWTO (RINDEX_16C_REG16_C),
114
  /* 24 */ ONLY_NAME_HOWTO (RINDEX_16C_REG20),
115
  /* 25 */ ONLY_NAME_HOWTO (RINDEX_16C_REG20_C),
116
  /* 26 */ ONLY_NAME_HOWTO (RINDEX_16C_ABS20),
117
  /* 27 */ ONLY_NAME_HOWTO (RINDEX_16C_ABS20_C),
118
  /* 28 */ ONLY_NAME_HOWTO (RINDEX_16C_ABS24),
119
  /* 29 */ ONLY_NAME_HOWTO (RINDEX_16C_ABS24_C),
120
  /* 30 */ ONLY_NAME_HOWTO (RINDEX_16C_IMM04),
121
  /* 31 */ ONLY_NAME_HOWTO (RINDEX_16C_IMM04_C),
122
  /* 32 */ ONLY_NAME_HOWTO (RINDEX_16C_IMM16),
123
  /* 33 */ ONLY_NAME_HOWTO (RINDEX_16C_IMM16_C),
124
  /* 34 */ ONLY_NAME_HOWTO (RINDEX_16C_IMM20),
125
  /* 35 */ ONLY_NAME_HOWTO (RINDEX_16C_IMM20_C),
126
  /* 36 */ ONLY_NAME_HOWTO (RINDEX_16C_IMM24),
127
  /* 37 */ ONLY_NAME_HOWTO (RINDEX_16C_IMM24_C),
128
  /* 38 */ ONLY_NAME_HOWTO (RINDEX_16C_IMM32),
129
  /* 39 */ ONLY_NAME_HOWTO (RINDEX_16C_IMM32_C)
130
};
131
 
132
 
133
/* Code to turn a code_type into a howto ptr, uses the above howto table.  */
134
 
135
static reloc_howto_type *
136
elf_cr16c_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
137
                             bfd_reloc_code_real_type code)
138
{
139
  unsigned int i;
140
 
141
  for (i = 0; i < RINDEX_16C_MAX; i++)
142
    {
143
      if (code == reloc_map_index[i].bfd_reloc_enum)
144
        {
145
          /* printf ("CR16C Relocation Type is - %x\n", code); */
146
          return & elf_howto_table[i];
147
        }
148
    }
149
 
150
  /* printf ("This relocation Type is not supported - %x\n", code); */
151
  return 0;
152
}
153
 
154
static reloc_howto_type *
155
elf_cr16c_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
156
                             const char *r_name)
157
{
158
  unsigned int i;
159
 
160
  for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
161
    if (elf_howto_table[i].name != NULL
162
        && strcasecmp (elf_howto_table[i].name, r_name) == 0)
163
      return &elf_howto_table[i];
164
 
165
  return NULL;
166
}
167
 
168
static void
169
elf_cr16c_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
170
                         arelent *cache_ptr ATTRIBUTE_UNUSED,
171
                         Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
172
{
173
  abort ();
174
}
175
 
176
static void
177
elf_cr16c_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
178
                             arelent *cache_ptr,
179
                             Elf_Internal_Rela *dst)
180
{
181
  unsigned int r_type = ELF32_R_TYPE (dst->r_info);
182
 
183
  BFD_ASSERT (r_type < (unsigned int) RINDEX_16C_MAX);
184
  cache_ptr->howto = &elf_howto_table[r_type];
185
}
186
 
187
/* Perform a relocation as part of a final link.  */
188
 
189
static bfd_reloc_status_type
190
cr16c_elf_final_link_relocate (reloc_howto_type *howto,
191
                               bfd *abfd,
192
                               bfd *output_bfd ATTRIBUTE_UNUSED,
193
                               asection *input_section,
194
                               bfd_byte *data,
195
                               bfd_vma octets,
196
                               bfd_vma Rvalue,
197
                               bfd_vma addend ATTRIBUTE_UNUSED,
198
                               struct bfd_link_info *info ATTRIBUTE_UNUSED,
199
                               asection *sym_sec ATTRIBUTE_UNUSED,
200
                               int is_local ATTRIBUTE_UNUSED)
201
{
202
  long value;
203
  short sword;                  /* Extracted from the hole and put back.  */
204
  unsigned long format, addr_type, code_factor;
205
  unsigned short size;
206
  unsigned short r_type;
207
  asymbol *symbol = NULL;
208
 
209
  unsigned long disp20_opcod;
210
  char neg = 0;
211
  char neg2pos = 0;
212
 
213
  long left_val = 0;
214
  long plus_factor = 0;          /* To be added to the hole.  */
215
 
216
#define MIN_BYTE        ((int) 0xFFFFFF80)
217
#define MIN_WORD        ((int) 0xFFFF8000)
218
#define MAX_UWORD       ((unsigned) 0x0000FFFF)
219
#define MAX_UBYTE       ((unsigned) 0x000000FF)
220
 
221
  r_type = reloc_map_index[howto->type].cr_reloc_type;
222
  format = r_type & R_FORMAT;
223
  size = r_type & R_SIZESP;
224
  addr_type = r_type & R_ADDRTYPE;
225
  code_factor = ((addr_type == R_CODE_ADDR) ? 1 : 0);
226
 
227
  if (sym_sec)
228
    symbol = sym_sec->symbol;
229
 
230
  switch (format)
231
    {
232
    case R_NUMBER:
233
      switch (size)
234
        {
235
        case R_S_16C_08:        /* One byte.  */
236
          value = bfd_get_8 (abfd, (char *) data + octets);
237
          break;
238
        case R_S_16C_16:        /* Two bytes. */
239
          sword = bfd_get_16 (abfd, (bfd_byte *) data + octets);
240
          value = sword;
241
          break;
242
        case R_S_16C_32:        /* Four bytes.  */
243
          value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
244
          break;
245
        default:
246
          return bfd_reloc_notsupported;
247
        }
248
      break;
249
 
250
    case R_16C_DISPL:
251
      switch (size)
252
        {
253
        case R_S_16C_04:    /* word1(4-7).  */
254
          value = bfd_get_8 (abfd, (char *) data + octets);
255
          left_val = value & 0xF;
256
          value = (value & 0xF0) >> 4;
257
          value++;
258
          value <<= 1;
259
          break;
260
        case R_S_16C_08:    /* word1(0-3,8-11).  */
261
          sword = bfd_get_16 (abfd, (char *) data + octets);
262
          value = sword & 0x000F;
263
          value |= ((sword & 0x0F00) >> 4);
264
          left_val = sword & 0xF0F0;
265
          value <<= 1;
266
          if (value & 0x100)
267
            value |= 0xFFFFFF00;
268
          break;
269
        case R_S_16C_16:    /* word2.  */
270
          sword = bfd_get_16 (abfd, (bfd_byte *) data + octets);
271
          value = sword;
272
          value = ((value & 0xFFFE) >> 1) | ((value & 0x1) << 15);
273
          value <<= 1;
274
          if (value & 0x10000)
275
            value |= 0xFFFF0000;
276
          break;
277
        case R_S_16C_24_a:      /* word1(0-7),word2.  */
278
          value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
279
          left_val = value & 0x0000FF00;
280
          value = ((value & 0xFFFE0000) >> 17) |
281
            ((value & 0x00010000) << 7) | ((value & 0x000000FF) << 15);
282
          value <<= 1;
283
          if (value & 0x1000000)
284
            value |= 0xFE000000;
285
          break;
286
        case R_S_16C_24:    /* word2(0-3,8-11),word3.  */
287
          value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
288
          left_val = value & 0x0000F0F0;
289
          value = ((value >> 16) & 0x0000FFFF) |
290
            ((value & 0x00000F00) << 8) | ((value & 0x0000000F) << 20);
291
 
292
          value = ((value & 0x00FFFFFE) >> 1) | ((value & 0x00000001) << 23);
293
 
294
          value <<= 1;
295
          if (value & 0x1000000)
296
            value |= 0xFE000000;
297
          break;
298
        default:
299
          return bfd_reloc_notsupported;
300
        }
301
      break;
302
 
303
    case R_16C_REGREL:
304
      switch (size)
305
        {
306
        case R_S_16C_04:    /* word1(12-15) not scaled.  */
307
          value = bfd_get_8 (abfd, (char *) data + octets);
308
          left_val = value & 0xF0;
309
          value = value & 0xF;
310
          break;
311
        case R_S_16C_04_a:      /* word1(12-15) scaled by 2.  */
312
          value = bfd_get_8 (abfd, (char *) data + octets);
313
          left_val = value & 0xF0;
314
          value = value & 0xF;
315
          value <<= 1;
316
          break;
317
        case R_S_16C_14:    /* word1(4-5),word2(0-3,8-15).  */
318
          value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
319
          left_val = value & 0x00F0FFCF;
320
          value = ((value & 0xc0000000) >> 24) |
321
            ((value & 0x3F000000) >> 16) |
322
            ((value & 0x000F0000) >> 16) | (value & 0x00000030);
323
          break;
324
        case R_S_16C_16:    /* word2.  */
325
          sword = bfd_get_16 (abfd, (bfd_byte *) data + octets);
326
          value = sword;
327
          break;
328
        case R_S_16C_20:    /* word2(8-11),word3.  */
329
          value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
330
          left_val = value & 0xF0;
331
          value = (value & 0xF) << 16;
332
          sword = bfd_get_16 (abfd, (bfd_byte *) data + octets + 1);
333
          value = value | (unsigned short) sword;
334
          disp20_opcod = bfd_get_32 (abfd, (bfd_byte *) data + octets - 3);
335
          disp20_opcod |= 0x0FFF0000;
336
          if ((disp20_opcod == 0x4FFF0018) ||   /* loadb -disp20(reg) */
337
              (disp20_opcod == 0x5FFF0018) ||   /* loadb -disp20(rp)  */
338
              (disp20_opcod == 0x8FFF0018) ||   /* loadd -disp20(reg) */
339
              (disp20_opcod == 0x9FFF0018) ||   /* loadd -disp20(rp)  */
340
              (disp20_opcod == 0xCFFF0018) ||   /* loadw -disp20(reg) */
341
              (disp20_opcod == 0xDFFF0018) ||   /* loadw -disp20(rp)  */
342
              (disp20_opcod == 0x4FFF0019) ||   /* storb -disp20(reg) */
343
              (disp20_opcod == 0x5FFF0019) ||   /* storb -disp20(rp)  */
344
              (disp20_opcod == 0x8FFF0019) ||   /* stord -disp20(reg) */
345
              (disp20_opcod == 0x9FFF0019) ||   /* stord -disp20(rp)  */
346
              (disp20_opcod == 0xCFFF0019) ||   /* storw -disp20(reg) */
347
              (disp20_opcod == 0xDFFF0019))
348
            {   /* storw -disp20(rp).  */
349
              neg = 1;
350
              value |= 0xFFF00000;
351
            }
352
 
353
          break;
354
        default:
355
          return bfd_reloc_notsupported;
356
        }
357
      break;
358
 
359
    case R_16C_ABS:
360
      switch (size)
361
        {
362
        case R_S_16C_20:    /* word1(0-3),word2.  */
363
          value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
364
          left_val = value & 0x0000FFF0;
365
          value = ((value & 0xFFFF0000) >> 16) |
366
            ((value & 0x0000000F) << 16);
367
          break;
368
        case R_S_16C_24:   /* word2(0-3,8-11),word3.  */
369
          value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
370
          left_val = value & 0x0000F0F0;
371
          value = ((value & 0xFFFF0000) >> 16) |
372
            ((value & 0x00000F00) << 8) | ((value & 0x0000000F) << 20);
373
          break;
374
        default:
375
          return bfd_reloc_notsupported;
376
        }
377
      break;
378
 
379
    case R_16C_IMMED:
380
      switch (size)
381
        {
382
        case R_S_16C_04:    /* word1/2(4-7).  */
383
          value = bfd_get_8 (abfd, (char *) data + octets);
384
          left_val = value & 0xF;
385
          value = (value & 0xF0) >> 4;
386
          break;
387
        case R_S_16C_16:    /* word2.  */
388
          sword = bfd_get_16 (abfd, (bfd_byte *) data + octets);
389
          value = sword;
390
          break;
391
        case R_S_16C_20:    /* word1(0-3),word2.  */
392
          value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
393
          left_val = value & 0x0000FFF0;
394
          value = ((value & 0xFFFF0000) >> 16) |
395
            ((value & 0x0000000F) << 16);
396
          break;
397
        case R_S_16C_32:    /* word2, word3.  */
398
          value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
399
          value = ((value & 0x0000FFFF) << 16) |
400
            ((value & 0xFFFF0000) >> 16);
401
          break;
402
        default:
403
          return bfd_reloc_notsupported;
404
        }
405
      break;
406
    default:
407
      return bfd_reloc_notsupported;
408
    }
409
 
410
  switch ((r_type & R_RELTO) >> 4)
411
    {
412
 
413
    case 0:      /* R_ABS.  */
414
      plus_factor = Rvalue;
415
      break;
416
    case 1:     /* R_PCREL.  */
417
      plus_factor = Rvalue -
418
        (input_section->output_section->vma + input_section->output_offset);
419
      break;
420
    default:
421
      return bfd_reloc_notsupported;
422
    }
423
 
424
  if (neg)
425
    {
426
      if (plus_factor >= -value)
427
        neg2pos = 1;
428
      /* We need to change load/stor with negative
429
         displ opcode to positive disp opcode (CR16C).  */
430
    }
431
 
432
  value = value + (plus_factor >> code_factor);
433
 
434
  switch (format)
435
    {
436
    case R_NUMBER:
437
      switch (size)
438
        {
439
        case R_S_16C_08:        /* One byte.  */
440
          if (value > (int) MAX_UBYTE || value < MIN_BYTE)
441
            return bfd_reloc_overflow;
442
          value &= 0xFF;
443
          bfd_put_8 (abfd, (bfd_vma) value, (unsigned char *) data + octets);
444
          break;
445
 
446
        case R_S_16C_16:        /* Two bytes.  */
447
          if (value > (int) MAX_UWORD || value < MIN_WORD)
448
            return bfd_reloc_overflow;
449
          value &= 0xFFFF;
450
          sword = value;
451
          bfd_put_16 (abfd, (bfd_vma) sword,
452
                      (unsigned char *) data + octets);
453
          break;
454
 
455
        case R_S_16C_32:        /* Four bytes.  */
456
          value &= 0xFFFFFFFF;
457
          bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
458
          break;
459
 
460
        default:
461
          return bfd_reloc_notsupported;
462
        }
463
      break;
464
 
465
    case R_16C_DISPL:
466
      switch (size)
467
        {
468
        case R_S_16C_04:        /* word1(4-7).  */
469
          if ((value - 32) > 32 || value < 2)
470
            return bfd_reloc_overflow;
471
          value >>= 1;
472
          value--;
473
          value &= 0xF;
474
          value <<= 4;
475
          value |= left_val;
476
          bfd_put_8 (abfd, (bfd_vma) value, (unsigned char *) data + octets);
477
          break;
478
 
479
        case R_S_16C_08:    /* word1(0-3,8-11).  */
480
          if (value > 255 || value < -256 || value == 0x80)
481
            return bfd_reloc_overflow;
482
          value &= 0x1FF;
483
          value >>= 1;
484
          sword = value & 0x000F;
485
          sword |= (value & 0x00F0) << 4;
486
          sword |= left_val;
487
          bfd_put_16 (abfd, (bfd_vma) sword,
488
                      (unsigned char *) data + octets);
489
          break;
490
 
491
        case R_S_16C_16:    /* word2.  */
492
          if (value > 65535 || value < -65536)
493
            return bfd_reloc_overflow;
494
          value >>= 1;
495
          value &= 0xFFFF;
496
          value = ((value & 0x8000) >> 15) | ((value & 0x7FFF) << 1);
497
          sword = value;
498
          bfd_put_16 (abfd, (bfd_vma) sword,
499
                      (unsigned char *) data + octets);
500
          break;
501
 
502
        case R_S_16C_24_a:      /* word1(0-7),word2.  */
503
          if (value > 16777215 || value < -16777216)
504
            return bfd_reloc_overflow;
505
          value &= 0x1FFFFFF;
506
          value >>= 1;
507
          value = ((value & 0x00007FFF) << 17) |
508
            ((value & 0x00800000) >> 7) | ((value & 0x007F8000) >> 15);
509
          value |= left_val;
510
          bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
511
          break;
512
 
513
        case R_S_16C_24:    /* word2(0-3,8-11),word3.  */
514
          if (value > 16777215 || value < -16777216)
515
            return bfd_reloc_overflow;
516
          value &= 0x1FFFFFF;
517
          value >>= 1;
518
 
519
          value = ((value & 0x007FFFFF) << 1) | ((value & 0x00800000) >> 23);
520
 
521
          value = ((value & 0x0000FFFF) << 16) |
522
            ((value & 0x000F0000) >> 8) | ((value & 0x00F00000) >> 20);
523
          value |= left_val;
524
          bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
525
          break;
526
 
527
        default:
528
          return bfd_reloc_notsupported;
529
        }
530
      break;
531
 
532
    case R_16C_REGREL:
533
      switch (size)
534
        {
535
        case R_S_16C_04:        /* word1(12-15) not scaled.  */
536
          if (value > 13 || value < 0)
537
            return bfd_reloc_overflow;
538
          value &= 0xF;
539
          value |= left_val;
540
          bfd_put_8 (abfd, (bfd_vma) value, (unsigned char *) data + octets);
541
          break;
542
 
543
        case R_S_16C_04_a:      /* word1(12-15) not scaled.  */
544
          if (value > 26 || value < 0)
545
            return bfd_reloc_overflow;
546
          value &= 0x1F;
547
          value >>= 1;
548
          value |= left_val;
549
          bfd_put_8 (abfd, (bfd_vma) value, (unsigned char *) data + octets);
550
          break;
551
 
552
        case R_S_16C_14:        /* word1(4-5),word2(0-3,8-15).  */
553
          if (value < 0 || value > 16383)
554
            return bfd_reloc_overflow;
555
          value &= 0x3FFF;
556
          value = ((value & 0x000000c0) << 24) |
557
            ((value & 0x00003F00) << 16) |
558
            ((value & 0x0000000F) << 16) | (value & 0x00000030);
559
          value |= left_val;
560
          bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
561
          break;
562
 
563
        case R_S_16C_16:        /* word2.  */
564
          if (value > 65535 || value < 0)
565
            return bfd_reloc_overflow;
566
          value &= 0xFFFF;
567
          sword = value;
568
          bfd_put_16 (abfd, (bfd_vma) sword,
569
                      (unsigned char *) data + octets);
570
          break;
571
 
572
        case R_S_16C_20:        /* word2(8-11),word3.  */
573
          /* if (value > 1048575 || value < 0) RELOC_ERROR(1); */
574
          value &= 0xFFFFF;
575
          sword = value & 0x0000FFFF;
576
          value = (value & 0x000F0000) >> 16;
577
          value |= left_val;
578
          bfd_put_8 (abfd, (bfd_vma) value, (unsigned char *) data + octets);
579
          bfd_put_16 (abfd, (bfd_vma) sword,
580
                      (unsigned char *) data + octets + 1);
581
          if (neg2pos)
582
            {
583
              /* Change load/stor negative displ opcode
584
                 to load/stor positive displ opcode.  */
585
              value = bfd_get_8 (abfd, (char *) data + octets - 3);
586
              value &= 0xF7;
587
              value |= 0x2;
588
              bfd_put_8 (abfd, (bfd_vma) value,
589
                         (unsigned char *) data + octets - 3);
590
            }
591
          break;
592
 
593
        default:
594
          return bfd_reloc_notsupported;
595
        }
596
      break;
597
 
598
    case R_16C_ABS:
599
      switch (size)
600
        {
601
        case R_S_16C_20:        /* word1(0-3),word2.  */
602
          if (value > 1048575 || value < 0)
603
            return bfd_reloc_overflow;
604
          value &= 0xFFFFF;
605
          value = ((value & 0x0000FFFF) << 16) |
606
            ((value & 0x000F0000) >> 16);
607
          value |= left_val;
608
          bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
609
          break;
610
 
611
        case R_S_16C_24:        /* word2(0-3,8-11),word3.  */
612
          /* if (value > 16777215 || value < 0) RELOC_ERROR(1); */
613
          value &= 0xFFFFFF;
614
          value = ((value & 0x0000FFFF) << 16) |
615
            ((value & 0x000F0000) >> 8) | ((value & 0x00F00000) >> 20);
616
          value |= left_val;
617
          bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
618
          break;
619
 
620
        default:
621
          return bfd_reloc_notsupported;
622
        }
623
      break;
624
 
625
    case R_16C_IMMED:
626
      switch (size)
627
        {
628
        case R_S_16C_04:        /* word1/2(4-7).  */
629
          if (value > 15 || value < -1)
630
            return bfd_reloc_overflow;
631
          value &= 0xF;
632
          value <<= 4;
633
          value |= left_val;
634
          bfd_put_8 (abfd, (bfd_vma) value, (unsigned char *) data + octets);
635
          break;
636
 
637
        case R_S_16C_16:        /* word2.  */
638
          if (value > 32767 || value < -32768)
639
            return bfd_reloc_overflow;
640
          value &= 0xFFFF;
641
          sword = value;
642
          bfd_put_16 (abfd, (bfd_vma) sword,
643
                      (unsigned char *) data + octets);
644
          break;
645
 
646
        case R_S_16C_20:        /* word1(0-3),word2.  */
647
          if (value > 1048575 || value < 0)
648
            return bfd_reloc_overflow;
649
          value &= 0xFFFFF;
650
          value = ((value & 0x0000FFFF) << 16) |
651
            ((value & 0x000F0000) >> 16);
652
          value |= left_val;
653
          bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
654
          break;
655
 
656
        case R_S_16C_32:        /* word2, word3.  */
657
          value &= 0xFFFFFFFF;
658
          value = ((value & 0x0000FFFF) << 16) |
659
            ((value & 0xFFFF0000) >> 16);
660
          bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
661
          break;
662
 
663
        default:
664
          return bfd_reloc_notsupported;
665
        }
666
      break;
667
    default:
668
      return bfd_reloc_notsupported;
669
    }
670
 
671
  return bfd_reloc_ok;
672
}
673
 
674
/* Relocate a CR16C ELF section.  */
675
 
676
static bfd_boolean
677
elf32_cr16c_relocate_section (bfd *output_bfd,
678
                              struct bfd_link_info *info,
679
                              bfd *input_bfd,
680
                              asection *input_section,
681
                              bfd_byte *contents,
682
                              Elf_Internal_Rela *relocs,
683
                              Elf_Internal_Sym *local_syms,
684
                              asection **local_sections)
685
{
686
  Elf_Internal_Shdr *symtab_hdr;
687
  struct elf_link_hash_entry **sym_hashes;
688
  Elf_Internal_Rela *rel, *relend;
689
 
690
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
691
  sym_hashes = elf_sym_hashes (input_bfd);
692
 
693
  rel = relocs;
694
  relend = relocs + input_section->reloc_count;
695
  for (; rel < relend; rel++)
696
    {
697
      int r_type;
698
      reloc_howto_type *howto;
699
      unsigned long r_symndx;
700
      Elf_Internal_Sym *sym;
701
      asection *sec;
702
      struct elf_link_hash_entry *h;
703
      bfd_vma relocation;
704
      bfd_reloc_status_type r;
705
 
706
      r_symndx = ELF32_R_SYM (rel->r_info);
707
      r_type = ELF32_R_TYPE (rel->r_info);
708
      howto = elf_howto_table + r_type;
709
 
710
      h = NULL;
711
      sym = NULL;
712
      sec = NULL;
713
      if (r_symndx < symtab_hdr->sh_info)
714
        {
715
          sym = local_syms + r_symndx;
716
          sec = local_sections[r_symndx];
717
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
718
        }
719
      else
720
        {
721
          bfd_boolean unresolved_reloc, warned;
722
 
723
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
724
                                   r_symndx, symtab_hdr, sym_hashes,
725
                                   h, sec, relocation,
726
                                   unresolved_reloc, warned);
727
        }
728
 
729
      if (sec != NULL && elf_discarded_section (sec))
730
        {
731
          /* For relocs against symbols from removed linkonce sections,
732
             or sections discarded by a linker script, we just want the
733
             section contents zeroed.  Avoid any special processing.  */
734
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
735
          rel->r_info = 0;
736
          rel->r_addend = 0;
737
          continue;
738
        }
739
 
740
      if (info->relocatable)
741
        {
742
          /* This is a relocatable link.  We don't have to change
743
             anything, unless the reloc is against a section symbol,
744
             in which case we have to adjust according to where the
745
             section symbol winds up in the output section.  */
746
          if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
747
            rel->r_addend += sec->output_offset;
748
          continue;
749
        }
750
 
751
      r = cr16c_elf_final_link_relocate (howto, input_bfd, output_bfd,
752
                                         input_section,
753
                                         contents, rel->r_offset,
754
                                         relocation, rel->r_addend,
755
                                         info, sec, h == NULL);
756
 
757
      if (r != bfd_reloc_ok)
758
        {
759
          const char *name;
760
          const char *msg = (const char *) 0;
761
 
762
          if (h != NULL)
763
            name = h->root.root.string;
764
          else
765
            {
766
              name = (bfd_elf_string_from_elf_section
767
                      (input_bfd, symtab_hdr->sh_link, sym->st_name));
768
              if (name == NULL || *name == '\0')
769
                name = bfd_section_name (input_bfd, sec);
770
            }
771
 
772
          switch (r)
773
            {
774
            case bfd_reloc_overflow:
775
              if (!((*info->callbacks->reloc_overflow)
776
                    (info, (h ? &h->root : NULL), name, howto->name,
777
                     (bfd_vma) 0, input_bfd, input_section,
778
                     rel->r_offset)))
779
                return FALSE;
780
              break;
781
 
782
            case bfd_reloc_undefined:
783
              if (!((*info->callbacks->undefined_symbol)
784
                    (info, name, input_bfd, input_section,
785
                     rel->r_offset, TRUE)))
786
                return FALSE;
787
              break;
788
 
789
            case bfd_reloc_outofrange:
790
              msg = _("internal error: out of range error");
791
              goto common_error;
792
 
793
            case bfd_reloc_notsupported:
794
              msg = _("internal error: unsupported relocation error");
795
              goto common_error;
796
 
797
            case bfd_reloc_dangerous:
798
              msg = _("internal error: dangerous error");
799
              goto common_error;
800
 
801
            default:
802
              msg = _("internal error: unknown error");
803
              /* fall through */
804
 
805
            common_error:
806
              if (!((*info->callbacks->warning)
807
                    (info, msg, name, input_bfd, input_section,
808
                     rel->r_offset)))
809
                return FALSE;
810
              break;
811
            }
812
        }
813
    }
814
 
815
  return TRUE;
816
}
817
 
818
/* CR16C ELF uses three common sections:
819
   One is for default common symbols (placed in usual common section).
820
   Second is for near common symbols (placed in "ncommon" section).
821
   Third is for far common symbols (placed in "fcommon" section).
822
   The following implementation is based on elf32-mips architecture */
823
 
824
static asection  cr16c_elf_fcom_section;
825
static asymbol   cr16c_elf_fcom_symbol;
826
static asymbol * cr16c_elf_fcom_symbol_ptr;
827
static asection  cr16c_elf_ncom_section;
828
static asymbol   cr16c_elf_ncom_symbol;
829
static asymbol * cr16c_elf_ncom_symbol_ptr;
830
 
831
/* Given a BFD section, try to locate the
832
   corresponding ELF section index.  */
833
 
834
static bfd_boolean
835
elf32_cr16c_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
836
                                      asection *sec,
837
                                      int *retval)
838
{
839
  if (strcmp (bfd_get_section_name (abfd, sec), ".fcommon") == 0)
840
    *retval = SHN_CR16C_FCOMMON;
841
  else if (strcmp (bfd_get_section_name (abfd, sec), ".ncommon") == 0)
842
    *retval = SHN_CR16C_NCOMMON;
843
  else
844
    return FALSE;
845
 
846
  return TRUE;
847
}
848
 
849
/* Handle the special CR16C section numbers that a symbol may use.  */
850
 
851
static void
852
elf32_cr16c_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
853
                               asymbol *asym)
854
{
855
  elf_symbol_type *elfsym = (elf_symbol_type *) asym;
856
  unsigned int indx;
857
 
858
  indx = elfsym->internal_elf_sym.st_shndx;
859
 
860
  switch (indx)
861
    {
862
    case SHN_CR16C_FCOMMON:
863
      if (cr16c_elf_fcom_section.name == NULL)
864
        {
865
          /* Initialize the far common section.  */
866
          cr16c_elf_fcom_section.name = ".fcommon";
867
          cr16c_elf_fcom_section.flags = SEC_IS_COMMON | SEC_ALLOC;
868
          cr16c_elf_fcom_section.output_section = &cr16c_elf_fcom_section;
869
          cr16c_elf_fcom_section.symbol = &cr16c_elf_fcom_symbol;
870
          cr16c_elf_fcom_section.symbol_ptr_ptr = &cr16c_elf_fcom_symbol_ptr;
871
          cr16c_elf_fcom_symbol.name = ".fcommon";
872
          cr16c_elf_fcom_symbol.flags = BSF_SECTION_SYM;
873
          cr16c_elf_fcom_symbol.section = &cr16c_elf_fcom_section;
874
          cr16c_elf_fcom_symbol_ptr = &cr16c_elf_fcom_symbol;
875
        }
876
      asym->section = &cr16c_elf_fcom_section;
877
      asym->value = elfsym->internal_elf_sym.st_size;
878
      break;
879
    case SHN_CR16C_NCOMMON:
880
      if (cr16c_elf_ncom_section.name == NULL)
881
        {
882
          /* Initialize the far common section.  */
883
          cr16c_elf_ncom_section.name = ".ncommon";
884
          cr16c_elf_ncom_section.flags = SEC_IS_COMMON | SEC_ALLOC;
885
          cr16c_elf_ncom_section.output_section = &cr16c_elf_ncom_section;
886
          cr16c_elf_ncom_section.symbol = &cr16c_elf_ncom_symbol;
887
          cr16c_elf_ncom_section.symbol_ptr_ptr = &cr16c_elf_ncom_symbol_ptr;
888
          cr16c_elf_ncom_symbol.name = ".ncommon";
889
          cr16c_elf_ncom_symbol.flags = BSF_SECTION_SYM;
890
          cr16c_elf_ncom_symbol.section = &cr16c_elf_ncom_section;
891
          cr16c_elf_ncom_symbol_ptr = &cr16c_elf_ncom_symbol;
892
        }
893
      asym->section = &cr16c_elf_ncom_section;
894
      asym->value = elfsym->internal_elf_sym.st_size;
895
      break;
896
    }
897
}
898
 
899
/* Hook called by the linker routine which adds symbols from an object
900
   file.  We must handle the special cr16c section numbers here.  */
901
 
902
static bfd_boolean
903
elf32_cr16c_add_symbol_hook (bfd *abfd,
904
                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
905
                             Elf_Internal_Sym *sym,
906
                             const char **namep ATTRIBUTE_UNUSED,
907
                             flagword *flagsp ATTRIBUTE_UNUSED,
908
                             asection **secp,
909
                             bfd_vma *valp)
910
{
911
  unsigned int indx = sym->st_shndx;
912
 
913
  switch (indx)
914
    {
915
    case SHN_CR16C_FCOMMON:
916
      *secp = bfd_make_section_old_way (abfd, ".fcommon");
917
      (*secp)->flags |= SEC_IS_COMMON;
918
      *valp = sym->st_size;
919
      break;
920
    case SHN_CR16C_NCOMMON:
921
      *secp = bfd_make_section_old_way (abfd, ".ncommon");
922
      (*secp)->flags |= SEC_IS_COMMON;
923
      *valp = sym->st_size;
924
      break;
925
    }
926
 
927
  return TRUE;
928
}
929
 
930
static int
931
elf32_cr16c_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
932
                                     const char *name ATTRIBUTE_UNUSED,
933
                                     Elf_Internal_Sym *sym,
934
                                     asection *input_sec,
935
                                     struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
936
{
937
  /* If we see a common symbol, which implies a relocatable link, then
938
     if a symbol was in a special common section in an input file, mark
939
     it as a special common in the output file.  */
940
 
941
  if (sym->st_shndx == SHN_COMMON)
942
    {
943
      if (strcmp (input_sec->name, ".fcommon") == 0)
944
        sym->st_shndx = SHN_CR16C_FCOMMON;
945
      else if (strcmp (input_sec->name, ".ncommon") == 0)
946
        sym->st_shndx = SHN_CR16C_NCOMMON;
947
    }
948
 
949
  return 1;
950
}
951
 
952
/* Definitions for setting CR16C target vector.  */
953
#define TARGET_LITTLE_SYM               bfd_elf32_cr16c_vec
954
#define TARGET_LITTLE_NAME              "elf32-cr16c"
955
#define ELF_ARCH                        bfd_arch_cr16c
956
#define ELF_MACHINE_CODE                EM_CR
957
#define ELF_MAXPAGESIZE                 0x1
958
#define elf_symbol_leading_char         '_'
959
 
960
#define bfd_elf32_bfd_reloc_type_lookup         elf_cr16c_reloc_type_lookup
961
#define bfd_elf32_bfd_reloc_name_lookup elf_cr16c_reloc_name_lookup
962
#define elf_info_to_howto                       elf_cr16c_info_to_howto
963
#define elf_info_to_howto_rel                   elf_cr16c_info_to_howto_rel
964
#define elf_backend_relocate_section            elf32_cr16c_relocate_section
965
#define elf_backend_symbol_processing           elf32_cr16c_symbol_processing
966
#define elf_backend_section_from_bfd_section    elf32_cr16c_section_from_bfd_section
967
#define elf_backend_add_symbol_hook             elf32_cr16c_add_symbol_hook
968
#define elf_backend_link_output_symbol_hook     elf32_cr16c_link_output_symbol_hook
969
 
970
#define elf_backend_can_gc_sections     1
971
 
972
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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