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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [bfd/] [elf32-cr16.c] - Blame information for rev 38

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

Line No. Rev Author Line
1 38 julius
/* BFD back-end for National Semiconductor's CR16 ELF
2
   Copyright 2007 Free Software Foundation, Inc.
3
   Written by M R Swami Reddy.
4
 
5
   This file is part of BFD, the Binary File Descriptor library.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software Foundation,
19
   Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
20
 
21
#include "sysdep.h"
22
#include "bfd.h"
23
#include "bfdlink.h"
24
#include "libbfd.h"
25
#include "libiberty.h"
26
#include "elf-bfd.h"
27
#include "elf/cr16.h"
28
 
29
/* cr16_reloc_map array maps BFD relocation enum into a CRGAS relocation type.  */
30
 
31
struct cr16_reloc_map
32
{
33
  bfd_reloc_code_real_type bfd_reloc_enum; /* BFD relocation enum.  */
34
  unsigned short cr16_reloc_type;          /* CR16 relocation type.  */
35
};
36
 
37
static const struct cr16_reloc_map cr16_reloc_map[R_CR16_MAX] =
38
{
39
  {BFD_RELOC_NONE,           R_CR16_NONE},
40
  {BFD_RELOC_CR16_NUM8,      R_CR16_NUM8},
41
  {BFD_RELOC_CR16_NUM16,     R_CR16_NUM16},
42
  {BFD_RELOC_CR16_NUM32,     R_CR16_NUM32},
43
  {BFD_RELOC_CR16_NUM32a,    R_CR16_NUM32a},
44
  {BFD_RELOC_CR16_REGREL4,   R_CR16_REGREL4},
45
  {BFD_RELOC_CR16_REGREL4a,  R_CR16_REGREL4a},
46
  {BFD_RELOC_CR16_REGREL14,  R_CR16_REGREL14},
47
  {BFD_RELOC_CR16_REGREL14a, R_CR16_REGREL14a},
48
  {BFD_RELOC_CR16_REGREL16,  R_CR16_REGREL16},
49
  {BFD_RELOC_CR16_REGREL20,  R_CR16_REGREL20},
50
  {BFD_RELOC_CR16_REGREL20a, R_CR16_REGREL20a},
51
  {BFD_RELOC_CR16_ABS20,     R_CR16_ABS20},
52
  {BFD_RELOC_CR16_ABS24,     R_CR16_ABS24},
53
  {BFD_RELOC_CR16_IMM4,      R_CR16_IMM4},
54
  {BFD_RELOC_CR16_IMM8,      R_CR16_IMM8},
55
  {BFD_RELOC_CR16_IMM16,     R_CR16_IMM16},
56
  {BFD_RELOC_CR16_IMM20,     R_CR16_IMM20},
57
  {BFD_RELOC_CR16_IMM24,     R_CR16_IMM24},
58
  {BFD_RELOC_CR16_IMM32,     R_CR16_IMM32},
59
  {BFD_RELOC_CR16_IMM32a,    R_CR16_IMM32a},
60
  {BFD_RELOC_CR16_DISP4,     R_CR16_DISP4},
61
  {BFD_RELOC_CR16_DISP8,     R_CR16_DISP8},
62
  {BFD_RELOC_CR16_DISP16,    R_CR16_DISP16},
63
  {BFD_RELOC_CR16_DISP24,    R_CR16_DISP24},
64
  {BFD_RELOC_CR16_DISP24a,   R_CR16_DISP24a},
65
  {BFD_RELOC_CR16_SWITCH8,   R_CR16_SWITCH8},
66
  {BFD_RELOC_CR16_SWITCH16,  R_CR16_SWITCH16},
67
  {BFD_RELOC_CR16_SWITCH32,  R_CR16_SWITCH32}
68
};
69
 
70
static reloc_howto_type cr16_elf_howto_table[] =
71
{
72
  HOWTO (R_CR16_NONE,              /* type */
73
         0,                        /* rightshift */
74
         2,                        /* size */
75
         32,                       /* bitsize */
76
         FALSE,                    /* pc_relative */
77
         0,                        /* bitpos */
78
         complain_overflow_dont,   /* complain_on_overflow */
79
         bfd_elf_generic_reloc,    /* special_function */
80
         "R_CR16_NONE",            /* name */
81
         FALSE,                    /* partial_inplace */
82
         0,                        /* src_mask */
83
         0,                        /* dst_mask */
84
         FALSE),                   /* pcrel_offset */
85
 
86
  HOWTO (R_CR16_NUM8,              /* type */
87
         0,                        /* rightshift */
88
         0,                        /* size */
89
         8,                        /* bitsize */
90
         FALSE,                    /* pc_relative */
91
         0,                        /* bitpos */
92
         complain_overflow_bitfield,/* complain_on_overflow */
93
         bfd_elf_generic_reloc,    /* special_function */
94
         "R_CR16_NUM8",            /* name */
95
         FALSE,                    /* partial_inplace */
96
         0xff,                     /* src_mask */
97
         0xff,                     /* dst_mask */
98
         FALSE),                   /* pcrel_offset */
99
 
100
  HOWTO (R_CR16_NUM16,             /* type */
101
         0,                        /* rightshift */
102
         1,                        /* size */
103
         16,                       /* bitsize */
104
         FALSE,                    /* pc_relative */
105
         0,                        /* bitpos */
106
         complain_overflow_bitfield,/* complain_on_overflow */
107
         bfd_elf_generic_reloc,    /* special_function */
108
         "R_CR16_NUM16",           /* name */
109
         FALSE,                    /* partial_inplace */
110
         0xffff,                   /* src_mask */
111
         0xffff,                   /* dst_mask */
112
         FALSE),                   /* pcrel_offset */
113
 
114
  HOWTO (R_CR16_NUM32,             /* type */
115
         0,                        /* rightshift */
116
         2,                        /* size */
117
         32,                       /* bitsize */
118
         FALSE,                    /* pc_relative */
119
         0,                        /* bitpos */
120
         complain_overflow_bitfield,/* complain_on_overflow */
121
         bfd_elf_generic_reloc,    /* special_function */
122
         "R_CR16_NUM32",           /* name */
123
         FALSE,                    /* partial_inplace */
124
         0xffffffff,               /* src_mask */
125
         0xffffffff,               /* dst_mask */
126
         FALSE),                   /* pcrel_offset */
127
 
128
  HOWTO (R_CR16_NUM32a,            /* type */
129
         1,                        /* rightshift */
130
         2,                        /* size */
131
         32,                       /* bitsize */
132
         FALSE,                    /* pc_relative */
133
         0,                        /* bitpos */
134
         complain_overflow_bitfield,/* complain_on_overflow */
135
         bfd_elf_generic_reloc,    /* special_function */
136
         "R_CR16_NUM32a",          /* name */
137
         FALSE,                    /* partial_inplace */
138
         0xffffffff,               /* src_mask */
139
         0xffffffff,               /* dst_mask */
140
         FALSE),                   /* pcrel_offset */
141
 
142
  HOWTO (R_CR16_REGREL4,           /* type */
143
         0,                        /* rightshift */
144
         0,                        /* size */
145
         4,                        /* bitsize */
146
         FALSE,                    /* pc_relative */
147
         0,                        /* bitpos */
148
         complain_overflow_bitfield,/* complain_on_overflow */
149
         bfd_elf_generic_reloc,    /* special_function */
150
         "R_CR16_REGREL4",         /* name */
151
         FALSE,                    /* partial_inplace */
152
         0xf,                      /* src_mask */
153
         0xf,                      /* dst_mask */
154
         FALSE),                   /* pcrel_offset */
155
 
156
  HOWTO (R_CR16_REGREL4a,          /* type */
157
         0,                        /* rightshift */
158
         0,                        /* size */
159
         4,                        /* bitsize */
160
         FALSE,                    /* pc_relative */
161
         0,                        /* bitpos */
162
         complain_overflow_bitfield,/* complain_on_overflow */
163
         bfd_elf_generic_reloc,    /* special_function */
164
         "R_CR16_REGREL4a",        /* name */
165
         FALSE,                    /* partial_inplace */
166
         0xf,                      /* src_mask */
167
         0xf,                      /* dst_mask */
168
         FALSE),                   /* pcrel_offset */
169
 
170
  HOWTO (R_CR16_REGREL14,          /* type */
171
         0,                        /* rightshift */
172
         1,                        /* size */
173
         14,                       /* bitsize */
174
         FALSE,                    /* pc_relative */
175
         0,                        /* bitpos */
176
         complain_overflow_bitfield,/* complain_on_overflow */
177
         bfd_elf_generic_reloc,    /* special_function */
178
         "R_CR16_REGREL14",        /* name */
179
         FALSE,                    /* partial_inplace */
180
         0x3fff,                   /* src_mask */
181
         0x3fff,                   /* dst_mask */
182
         FALSE),                   /* pcrel_offset */
183
 
184
  HOWTO (R_CR16_REGREL14a,         /* type */
185
         0,                        /* rightshift */
186
         1,                        /* size */
187
         14,                       /* bitsize */
188
         FALSE,                    /* pc_relative */
189
         0,                        /* bitpos */
190
         complain_overflow_bitfield,/* complain_on_overflow */
191
         bfd_elf_generic_reloc,    /* special_function */
192
         "R_CR16_REGREL14a",       /* name */
193
         FALSE,                    /* partial_inplace */
194
         0x3fff,                   /* src_mask */
195
         0x3fff,                   /* dst_mask */
196
         FALSE),                   /* pcrel_offset */
197
 
198
  HOWTO (R_CR16_REGREL16,          /* type */
199
         0,                        /* rightshift */
200
         1,                        /* size */
201
         16,                       /* bitsize */
202
         FALSE,                    /* pc_relative */
203
         0,                        /* bitpos */
204
         complain_overflow_bitfield,/* complain_on_overflow */
205
         bfd_elf_generic_reloc,    /* special_function */
206
         "R_CR16_REGREL16",        /* name */
207
         FALSE,                    /* partial_inplace */
208
         0xffff,                   /* src_mask */
209
         0xffff,                   /* dst_mask */
210
         FALSE),                   /* pcrel_offset */
211
 
212
  HOWTO (R_CR16_REGREL20,          /* type */
213
         0,                        /* rightshift */
214
         2,                        /* size */
215
         20,                       /* bitsize */
216
         FALSE,                    /* pc_relative */
217
         0,                        /* bitpos */
218
         complain_overflow_bitfield,/* complain_on_overflow */
219
         bfd_elf_generic_reloc,    /* special_function */
220
         "R_CR16_REGREL20",        /* name */
221
         FALSE,                    /* partial_inplace */
222
         0xfffff,                  /* src_mask */
223
         0xfffff,                  /* dst_mask */
224
         FALSE),                   /* pcrel_offset */
225
 
226
  HOWTO (R_CR16_REGREL20a,         /* type */
227
         0,                        /* rightshift */
228
         2,                        /* size */
229
         20,                       /* bitsize */
230
         FALSE,                    /* pc_relative */
231
         0,                        /* bitpos */
232
         complain_overflow_bitfield,/* complain_on_overflow */
233
         bfd_elf_generic_reloc,    /* special_function */
234
         "R_CR16_REGREL20a",       /* name */
235
         FALSE,                    /* partial_inplace */
236
         0xfffff,                  /* src_mask */
237
         0xfffff,                  /* dst_mask */
238
         FALSE),                   /* pcrel_offset */
239
 
240
  HOWTO (R_CR16_ABS20,             /* type */
241
         0,                        /* rightshift */
242
         2,                        /* size */
243
         20,                       /* bitsize */
244
         FALSE,                    /* pc_relative */
245
         0,                        /* bitpos */
246
         complain_overflow_bitfield,/* complain_on_overflow */
247
         bfd_elf_generic_reloc,    /* special_function */
248
         "R_CR16_ABS20",           /* name */
249
         FALSE,                    /* partial_inplace */
250
         0xfffff,                  /* src_mask */
251
         0xfffff,                  /* dst_mask */
252
         FALSE),                   /* pcrel_offset */
253
 
254
  HOWTO (R_CR16_ABS24,             /* type */
255
         0,                        /* rightshift */
256
         2,                        /* size */
257
         24,                       /* bitsize */
258
         FALSE,                    /* pc_relative */
259
         0,                        /* bitpos */
260
         complain_overflow_bitfield,/* complain_on_overflow */
261
         bfd_elf_generic_reloc,    /* special_function */
262
         "R_CR16_ABS24",           /* name */
263
         FALSE,                    /* partial_inplace */
264
         0xffffff,                 /* src_mask */
265
         0xffffff,                 /* dst_mask */
266
         FALSE),                   /* pcrel_offset */
267
 
268
  HOWTO (R_CR16_IMM4,              /* type */
269
         0,                        /* rightshift */
270
         0,                        /* size */
271
         4,                        /* bitsize */
272
         FALSE,                    /* pc_relative */
273
         0,                        /* bitpos */
274
         complain_overflow_bitfield,/* complain_on_overflow */
275
         bfd_elf_generic_reloc,    /* special_function */
276
         "R_CR16_IMM4",            /* name */
277
         FALSE,                    /* partial_inplace */
278
         0xf,                      /* src_mask */
279
         0xf,                      /* dst_mask */
280
         FALSE),                   /* pcrel_offset */
281
 
282
  HOWTO (R_CR16_IMM8,              /* type */
283
         0,                        /* rightshift */
284
         0,                        /* size */
285
         8,                        /* bitsize */
286
         FALSE,                    /* pc_relative */
287
         0,                        /* bitpos */
288
         complain_overflow_bitfield,/* complain_on_overflow */
289
         bfd_elf_generic_reloc,    /* special_function */
290
         "R_CR16_IMM8",            /* name */
291
         FALSE,                    /* partial_inplace */
292
         0xff,                     /* src_mask */
293
         0xff,                     /* dst_mask */
294
         FALSE),                   /* pcrel_offset */
295
 
296
  HOWTO (R_CR16_IMM16,             /* type */
297
         0,                        /* rightshift */
298
         1,                        /* size */
299
         16,                       /* bitsize */
300
         FALSE,                    /* pc_relative */
301
         0,                        /* bitpos */
302
         complain_overflow_bitfield,/* complain_on_overflow */
303
         bfd_elf_generic_reloc,    /* special_function */
304
         "R_CR16_IMM16",           /* name */
305
         FALSE,                    /* partial_inplace */
306
         0xffff,                   /* src_mask */
307
         0xffff,                   /* dst_mask */
308
         FALSE),                   /* pcrel_offset */
309
 
310
  HOWTO (R_CR16_IMM20,             /* type */
311
         0,                        /* rightshift */
312
         2,                        /* size */
313
         20,                       /* bitsize */
314
         FALSE,                    /* pc_relative */
315
         0,                        /* bitpos */
316
         complain_overflow_bitfield,/* complain_on_overflow */
317
         bfd_elf_generic_reloc,    /* special_function */
318
         "R_CR16_IMM20",           /* name */
319
         FALSE,                    /* partial_inplace */
320
         0xfffff,                  /* src_mask */
321
         0xfffff,                  /* dst_mask */
322
         FALSE),                   /* pcrel_offset */
323
 
324
  HOWTO (R_CR16_IMM24,             /* type */
325
         0,                        /* rightshift */
326
         2,                        /* size */
327
         24,                       /* bitsize */
328
         FALSE,                    /* pc_relative */
329
         0,                        /* bitpos */
330
         complain_overflow_bitfield,/* complain_on_overflow */
331
         bfd_elf_generic_reloc,    /* special_function */
332
         "R_CR16_IMM24",           /* name */
333
         FALSE,                    /* partial_inplace */
334
         0xffffff,                 /* src_mask */
335
         0xffffff,                 /* dst_mask */
336
         FALSE),                   /* pcrel_offset */
337
 
338
  HOWTO (R_CR16_IMM32,             /* type */
339
         0,                        /* rightshift */
340
         2,                        /* size */
341
         32,                       /* bitsize */
342
         FALSE,                    /* pc_relative */
343
         0,                        /* bitpos */
344
         complain_overflow_bitfield,/* complain_on_overflow */
345
         bfd_elf_generic_reloc,    /* special_function */
346
         "R_CR16_IMM32",           /* name */
347
         FALSE,                    /* partial_inplace */
348
         0xffffffff,               /* src_mask */
349
         0xffffffff,               /* dst_mask */
350
         FALSE),                   /* pcrel_offset */
351
 
352
  HOWTO (R_CR16_IMM32a,            /* type */
353
         1,                        /* rightshift */
354
         2,                        /* size */
355
         32,                       /* bitsize */
356
         FALSE,                    /* pc_relative */
357
         0,                        /* bitpos */
358
         complain_overflow_bitfield,/* complain_on_overflow */
359
         bfd_elf_generic_reloc,    /* special_function */
360
         "R_CR16_IMM32a",          /* name */
361
         FALSE,                    /* partial_inplace */
362
         0xffffffff,               /* src_mask */
363
         0xffffffff,               /* dst_mask */
364
         FALSE),                   /* pcrel_offset */
365
 
366
  HOWTO (R_CR16_DISP4,             /* type */
367
         1,                        /* rightshift */
368
         0,                        /* size (0 = byte, 1 = short, 2 = long) */
369
         4,                        /* bitsize */
370
         TRUE,                     /* pc_relative */
371
         0,                        /* bitpos */
372
         complain_overflow_unsigned, /* complain_on_overflow */
373
         bfd_elf_generic_reloc,    /* special_function */
374
         "R_CR16_DISP4",           /* name */
375
         FALSE,                    /* partial_inplace */
376
         0xf,                      /* src_mask */
377
         0xf,                      /* dst_mask */
378
         FALSE),                   /* pcrel_offset */
379
 
380
  HOWTO (R_CR16_DISP8,             /* type */
381
         1,                        /* rightshift */
382
         0,                        /* size (0 = byte, 1 = short, 2 = long) */
383
         8,                        /* bitsize */
384
         TRUE,                     /* pc_relative */
385
         0,                        /* bitpos */
386
         complain_overflow_unsigned, /* complain_on_overflow */
387
         bfd_elf_generic_reloc,    /* special_function */
388
         "R_CR16_DISP8",           /* name */
389
         FALSE,                    /* partial_inplace */
390
         0x1ff,                    /* src_mask */
391
         0x1ff,                    /* dst_mask */
392
         FALSE),                   /* pcrel_offset */
393
 
394
  HOWTO (R_CR16_DISP16,            /* type */
395
         0,                        /* rightshift REVIITS: To sync with WinIDEA*/
396
         1,                        /* size (0 = byte, 1 = short, 2 = long) */
397
         16,                       /* bitsize */
398
         TRUE,                     /* pc_relative */
399
         0,                        /* bitpos */
400
         complain_overflow_unsigned, /* complain_on_overflow */
401
         bfd_elf_generic_reloc,    /* special_function */
402
         "R_CR16_DISP16",          /* name */
403
         FALSE,                    /* partial_inplace */
404
         0x1ffff,                  /* src_mask */
405
         0x1ffff,                  /* dst_mask */
406
         FALSE),                   /* pcrel_offset */
407
  /* REVISIT: DISP24 should be left-shift by 2 as per ISA doc
408
     but its not done, to sync with WinIDEA and CR16 4.1 tools */
409
  HOWTO (R_CR16_DISP24,            /* type */
410
         0,                        /* rightshift */
411
         2,                        /* size (0 = byte, 1 = short, 2 = long) */
412
         24,                       /* bitsize */
413
         TRUE,                     /* pc_relative */
414
         0,                        /* bitpos */
415
         complain_overflow_unsigned, /* complain_on_overflow */
416
         bfd_elf_generic_reloc,    /* special_function */
417
         "R_CR16_DISP24",          /* name */
418
         FALSE,                    /* partial_inplace */
419
         0x1ffffff,                /* src_mask */
420
         0x1ffffff,                /* dst_mask */
421
         FALSE),                   /* pcrel_offset */
422
 
423
  HOWTO (R_CR16_DISP24a,           /* type */
424
         0,                        /* rightshift */
425
         2,                        /* size (0 = byte, 1 = short, 2 = long) */
426
         24,                       /* bitsize */
427
         TRUE,                     /* pc_relative */
428
         0,                        /* bitpos */
429
         complain_overflow_unsigned, /* complain_on_overflow */
430
         bfd_elf_generic_reloc,    /* special_function */
431
         "R_CR16_DISP24a",         /* name */
432
         FALSE,                    /* partial_inplace */
433
         0xffffff,                 /* src_mask */
434
         0xffffff,                 /* dst_mask */
435
         FALSE),                   /* pcrel_offset */
436
 
437
  /* An 8 bit switch table entry.  This is generated for an expression
438
     such as ``.byte L1 - L2''.  The offset holds the difference
439
     between the reloc address and L2.  */
440
  HOWTO (R_CR16_SWITCH8,           /* type */
441
         0,                        /* rightshift */
442
         0,                        /* size (0 = byte, 1 = short, 2 = long) */
443
         8,                        /* bitsize */
444
         FALSE,                    /* pc_relative */
445
         0,                        /* bitpos */
446
         complain_overflow_unsigned, /* complain_on_overflow */
447
         bfd_elf_generic_reloc,    /* special_function */
448
         "R_CR16_SWITCH8",         /* name */
449
         FALSE,                    /* partial_inplace */
450
         0xff,                     /* src_mask */
451
         0xff,                     /* dst_mask */
452
         TRUE),                    /* pcrel_offset */
453
 
454
  /* A 16 bit switch table entry.  This is generated for an expression
455
     such as ``.word L1 - L2''.  The offset holds the difference
456
     between the reloc address and L2.  */
457
  HOWTO (R_CR16_SWITCH16,          /* type */
458
         0,                        /* rightshift */
459
         1,                        /* size (0 = byte, 1 = short, 2 = long) */
460
         16,                       /* bitsize */
461
         FALSE,                    /* pc_relative */
462
         0,                        /* bitpos */
463
         complain_overflow_unsigned, /* complain_on_overflow */
464
         bfd_elf_generic_reloc,    /* special_function */
465
         "R_CR16_SWITCH16",        /* name */
466
         FALSE,                    /* partial_inplace */
467
         0xffff,                   /* src_mask */
468
         0xffff,                   /* dst_mask */
469
         TRUE),                    /* pcrel_offset */
470
 
471
  /* A 32 bit switch table entry.  This is generated for an expression
472
     such as ``.long L1 - L2''.  The offset holds the difference
473
     between the reloc address and L2.  */
474
  HOWTO (R_CR16_SWITCH32,          /* type */
475
         0,                        /* rightshift */
476
         2,                        /* size (0 = byte, 1 = short, 2 = long) */
477
         32,                       /* bitsize */
478
         FALSE,                    /* pc_relative */
479
         0,                        /* bitpos */
480
         complain_overflow_unsigned, /* complain_on_overflow */
481
         bfd_elf_generic_reloc,    /* special_function */
482
         "R_CR16_SWITCH32",        /* name */
483
         FALSE,                    /* partial_inplace */
484
         0xffffffff,               /* src_mask */
485
         0xffffffff,               /* dst_mask */
486
         TRUE)                     /* pcrel_offset */
487
};
488
 
489
/* Retrieve a howto ptr using a BFD reloc_code.  */
490
 
491
static reloc_howto_type *
492
elf_cr16_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
493
                            bfd_reloc_code_real_type code)
494
{
495
  unsigned int i;
496
 
497
  for (i = 0; i < R_CR16_MAX; i++)
498
    if (code == cr16_reloc_map[i].bfd_reloc_enum)
499
      return &cr16_elf_howto_table[cr16_reloc_map[i].cr16_reloc_type];
500
 
501
  _bfd_error_handler ("Unsupported CR16 relocation type: 0x%x\n", code);
502
  return NULL;
503
}
504
 
505
static reloc_howto_type *
506
elf_cr16_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
507
                            const char *r_name)
508
{
509
  unsigned int i;
510
 
511
  for (i = 0; ARRAY_SIZE (cr16_elf_howto_table); i++)
512
    if (cr16_elf_howto_table[i].name != NULL
513
        && strcasecmp (cr16_elf_howto_table[i].name, r_name) == 0)
514
      return cr16_elf_howto_table + i;
515
 
516
  return NULL;
517
}
518
 
519
/* Retrieve a howto ptr using an internal relocation entry.  */
520
 
521
static void
522
elf_cr16_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
523
                        Elf_Internal_Rela *dst)
524
{
525
  unsigned int r_type = ELF32_R_TYPE (dst->r_info);
526
 
527
  BFD_ASSERT (r_type < (unsigned int) R_CR16_MAX);
528
  cache_ptr->howto = &cr16_elf_howto_table[r_type];
529
}
530
 
531
/* Perform a relocation as part of a final link.  */
532
 
533
static bfd_reloc_status_type
534
cr16_elf_final_link_relocate (reloc_howto_type *howto,
535
                              bfd *input_bfd,
536
                              bfd *output_bfd ATTRIBUTE_UNUSED,
537
                              asection *input_section,
538
                              bfd_byte *contents,
539
                              bfd_vma offset,
540
                              bfd_vma Rvalue,
541
                              bfd_vma addend,
542
                              struct bfd_link_info *info ATTRIBUTE_UNUSED,
543
                              asection *sec ATTRIBUTE_UNUSED,
544
                              int is_local ATTRIBUTE_UNUSED)
545
{
546
  unsigned short r_type = howto->type;
547
  bfd_byte *hit_data = contents + offset;
548
  bfd_vma reloc_bits, check, Rvalue1;
549
 
550
  switch (r_type)
551
    {
552
     case R_CR16_IMM4:
553
     case R_CR16_IMM20:
554
     case R_CR16_ABS20:
555
       break;
556
 
557
     case R_CR16_IMM8:
558
     case R_CR16_IMM16:
559
     case R_CR16_IMM32:
560
     case R_CR16_IMM32a:
561
     case R_CR16_REGREL4:
562
     case R_CR16_REGREL4a:
563
     case R_CR16_REGREL14:
564
     case R_CR16_REGREL14a:
565
     case R_CR16_REGREL16:
566
     case R_CR16_REGREL20:
567
     case R_CR16_ABS24:
568
     case R_CR16_DISP16:
569
     case R_CR16_DISP24:
570
       /* 'hit_data' is relative to the start of the instruction, not the
571
           relocation offset. Advance it to account for the exact offset.  */
572
       hit_data += 2;
573
       break;
574
 
575
     case R_CR16_NONE:
576
       return bfd_reloc_ok;
577
       break;
578
 
579
     case R_CR16_DISP4:
580
       if (is_local)
581
         Rvalue += -1;
582
       break;
583
 
584
     case R_CR16_DISP8:
585
     case R_CR16_DISP24a:
586
       if (is_local)
587
         Rvalue -= -1;
588
       break;
589
 
590
     case R_CR16_SWITCH8:
591
     case R_CR16_SWITCH16:
592
     case R_CR16_SWITCH32:
593
       /* We only care about the addend, where the difference between
594
          expressions is kept.  */
595
       Rvalue = 0;
596
 
597
     default:
598
       break;
599
    }
600
 
601
  if (howto->pc_relative)
602
    {
603
      /* Subtract the address of the section containing the location.  */
604
      Rvalue -= (input_section->output_section->vma
605
                 + input_section->output_offset);
606
      /* Subtract the position of the location within the section.  */
607
      Rvalue -= offset;
608
    }
609
 
610
  /* Add in supplied addend.  */
611
  Rvalue += addend;
612
 
613
  /* Complain if the bitfield overflows, whether it is considered
614
     as signed or unsigned.  */
615
  check = Rvalue >> howto->rightshift;
616
 
617
  /* Assumes two's complement.  This expression avoids
618
     overflow if howto->bitsize is the number of bits in
619
     bfd_vma.  */
620
  reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
621
 
622
  if (((bfd_vma) check & ~reloc_bits) != 0
623
      && (((bfd_vma) check & ~reloc_bits)
624
      != (-(bfd_vma) 1 & ~reloc_bits)))
625
    {
626
      /* The above right shift is incorrect for a signed
627
         value.  See if turning on the upper bits fixes the
628
         overflow.  */
629
      if (howto->rightshift && (bfd_signed_vma) Rvalue < 0)
630
        {
631
          check |= ((bfd_vma) - 1
632
                    & ~((bfd_vma) - 1
633
                        >> howto->rightshift));
634
 
635
          if (((bfd_vma) check & ~reloc_bits)
636
              != (-(bfd_vma) 1 & ~reloc_bits))
637
             return bfd_reloc_overflow;
638
        }
639
      else
640
        return bfd_reloc_overflow;
641
    }
642
 
643
  /* Drop unwanted bits from the value we are relocating to.  */
644
  Rvalue >>= (bfd_vma) howto->rightshift;
645
 
646
  /* Apply dst_mask to select only relocatable part of the insn.  */
647
  Rvalue &= howto->dst_mask;
648
 
649
  switch (howto->size)
650
    {
651
      case 0:
652
        if (r_type == R_CR16_DISP8)
653
          {
654
             Rvalue1 = bfd_get_16 (input_bfd, hit_data);
655
             Rvalue = ((Rvalue1 & 0xf000) | ((Rvalue << 4) & 0xf00)
656
                       | (Rvalue1 & 0x00f0) | (Rvalue & 0xf));
657
             bfd_put_16 (input_bfd, Rvalue, hit_data);
658
          }
659
        else if (r_type == R_CR16_IMM4)
660
          {
661
             Rvalue1 = bfd_get_16 (input_bfd, hit_data);
662
             Rvalue = (((Rvalue1 & 0xff) << 8) | ((Rvalue << 4) & 0xf0)
663
                       | ((Rvalue1 & 0x0f00) >> 8));
664
             bfd_put_16 (input_bfd, Rvalue, hit_data);
665
          }
666
        else if (r_type == R_CR16_DISP4)
667
          {
668
             Rvalue1 = bfd_get_16 (input_bfd, hit_data);
669
             Rvalue = (Rvalue1 | ((Rvalue & 0xf) << 4));
670
             bfd_put_16 (input_bfd, Rvalue, hit_data);
671
          }
672
        else
673
          {
674
             bfd_put_8 (input_bfd, (unsigned char) Rvalue, hit_data);
675
          }
676
        break;
677
 
678
      case 1:
679
        if (r_type == R_CR16_DISP16)
680
          {
681
            Rvalue |= (bfd_get_16 (input_bfd, hit_data));
682
            Rvalue = ((Rvalue & 0xfffe) | ((Rvalue >> 16) & 0x1));
683
          }
684
 
685
          bfd_put_16 (input_bfd, Rvalue, hit_data);
686
        break;
687
 
688
      case 2:
689
        if ((r_type == R_CR16_ABS20) || (r_type == R_CR16_IMM20))
690
          {
691
             bfd_put_16 (input_bfd, (bfd_get_16 (input_bfd, hit_data))
692
                         | ((Rvalue >> 16) & 0xf), hit_data);
693
             bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
694
          }
695
        else
696
          {
697
            if (r_type == R_CR16_ABS24)
698
              {
699
                Rvalue = ((((Rvalue >> 20)& 0xf) | (((Rvalue >> 16) & 0xf) << 8)
700
                          | (bfd_get_16 (input_bfd, hit_data)))
701
                          | ((Rvalue & 0xffff) << 16));
702
              }
703
            if (r_type == R_CR16_DISP24)
704
              {
705
                Rvalue = ((((Rvalue >> 20)& 0xf) | (((Rvalue >>16) & 0xf) << 8)
706
                          | (bfd_get_16 (input_bfd, hit_data)))
707
                          | (((Rvalue & 0xfffe)
708
                              | ((Rvalue >> 24) & 0x1)) << 16));
709
              }
710
            else if ((r_type == R_CR16_IMM32) ||(r_type == R_CR16_IMM32a))
711
              {
712
                Rvalue = (((Rvalue >> 16)& 0xffff)
713
                          | (bfd_get_16 (input_bfd, hit_data)))
714
                          | ((Rvalue & 0xffff) << 16);
715
              }
716
            else if (r_type == R_CR16_DISP24a)
717
              {
718
                Rvalue = (((Rvalue & 0xfffffe) | (Rvalue >> 23)));
719
                Rvalue = ((Rvalue >> 16) & 0xff) | ((Rvalue & 0xffff) << 16)
720
                          | (bfd_get_32 (input_bfd, hit_data));
721
              }
722
 
723
            bfd_put_32 (input_bfd, Rvalue, hit_data);
724
          }
725
        break;
726
 
727
      default:
728
        return bfd_reloc_notsupported;
729
    }
730
 
731
  return bfd_reloc_ok;
732
}
733
 
734
/* Delete some bytes from a section while relaxing.  */
735
 
736
static bfd_boolean
737
elf32_cr16_relax_delete_bytes (struct bfd_link_info *link_info, bfd *abfd,
738
                               asection *sec, bfd_vma addr, int count)
739
{
740
  Elf_Internal_Shdr *symtab_hdr;
741
  unsigned int sec_shndx;
742
  bfd_byte *contents;
743
  Elf_Internal_Rela *irel, *irelend;
744
  Elf_Internal_Rela *irelalign;
745
  bfd_vma toaddr;
746
  Elf_Internal_Sym *isym;
747
  Elf_Internal_Sym *isymend;
748
  struct elf_link_hash_entry **sym_hashes;
749
  struct elf_link_hash_entry **end_hashes;
750
  struct elf_link_hash_entry **start_hashes;
751
  unsigned int symcount;
752
 
753
  sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
754
 
755
  contents = elf_section_data (sec)->this_hdr.contents;
756
 
757
  /* The deletion must stop at the next ALIGN reloc for an aligment
758
     power larger than the number of bytes we are deleting.  */
759
  irelalign = NULL;
760
  toaddr = sec->size;
761
 
762
  irel = elf_section_data (sec)->relocs;
763
  irelend = irel + sec->reloc_count;
764
 
765
  /* Actually delete the bytes.  */
766
  memmove (contents + addr, contents + addr + count,
767
           (size_t) (toaddr - addr - count));
768
  sec->size -= count;
769
 
770
  /* Adjust all the relocs.  */
771
  for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
772
    /* Get the new reloc address.  */
773
    if ((irel->r_offset > addr && irel->r_offset < toaddr))
774
        irel->r_offset -= count;
775
 
776
  /* Adjust the local symbols defined in this section.  */
777
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
778
  isym = (Elf_Internal_Sym *) symtab_hdr->contents;
779
  for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
780
    {
781
      if (isym->st_shndx == sec_shndx
782
          && isym->st_value > addr
783
          && isym->st_value < toaddr)
784
        {
785
          /* Adjust the addend of SWITCH relocations in this section,
786
             which reference this local symbol.  */
787
          for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
788
            {
789
              unsigned long r_symndx;
790
              Elf_Internal_Sym *rsym;
791
              bfd_vma addsym, subsym;
792
 
793
              /* Skip if not a SWITCH relocation.  */
794
              if (ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH8
795
                  && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH16
796
                  && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH32)
797
                continue;
798
 
799
              r_symndx = ELF32_R_SYM (irel->r_info);
800
              rsym = (Elf_Internal_Sym *) symtab_hdr->contents + r_symndx;
801
 
802
              /* Skip if not the local adjusted symbol.  */
803
              if (rsym != isym)
804
                continue;
805
 
806
              addsym = isym->st_value;
807
              subsym = addsym - irel->r_addend;
808
 
809
              /* Fix the addend only when -->> (addsym > addr >= subsym).  */
810
              if (subsym <= addr)
811
                irel->r_addend -= count;
812
              else
813
                continue;
814
            }
815
 
816
          isym->st_value -= count;
817
        }
818
    }
819
 
820
  /* Now adjust the global symbols defined in this section.  */
821
  symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
822
               - symtab_hdr->sh_info);
823
  sym_hashes = start_hashes = elf_sym_hashes (abfd);
824
  end_hashes = sym_hashes + symcount;
825
 
826
  for (; sym_hashes < end_hashes; sym_hashes++)
827
    {
828
      struct elf_link_hash_entry *sym_hash = *sym_hashes;
829
 
830
      /* The '--wrap SYMBOL' option is causing a pain when the object file,
831
         containing the definition of __wrap_SYMBOL, includes a direct
832
         call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
833
         the same symbol (which is __wrap_SYMBOL), but still exist as two
834
         different symbols in 'sym_hashes', we don't want to adjust
835
         the global symbol __wrap_SYMBOL twice.
836
         This check is only relevant when symbols are being wrapped.  */
837
      if (link_info->wrap_hash != NULL)
838
        {
839
          struct elf_link_hash_entry **cur_sym_hashes;
840
 
841
          /* Loop only over the symbols whom been already checked.  */
842
          for (cur_sym_hashes = start_hashes; cur_sym_hashes < sym_hashes;
843
               cur_sym_hashes++)
844
            /* If the current symbol is identical to 'sym_hash', that means
845
               the symbol was already adjusted (or at least checked).  */
846
            if (*cur_sym_hashes == sym_hash)
847
              break;
848
 
849
          /* Don't adjust the symbol again.  */
850
          if (cur_sym_hashes < sym_hashes)
851
            continue;
852
        }
853
 
854
      if ((sym_hash->root.type == bfd_link_hash_defined
855
          || sym_hash->root.type == bfd_link_hash_defweak)
856
          && sym_hash->root.u.def.section == sec
857
          && sym_hash->root.u.def.value > addr
858
          && sym_hash->root.u.def.value < toaddr)
859
        sym_hash->root.u.def.value -= count;
860
    }
861
 
862
  return TRUE;
863
}
864
 
865
/* Relocate a CR16 ELF section.  */
866
 
867
static bfd_boolean
868
elf32_cr16_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
869
                             bfd *input_bfd, asection *input_section,
870
                             bfd_byte *contents, Elf_Internal_Rela *relocs,
871
                             Elf_Internal_Sym *local_syms,
872
                             asection **local_sections)
873
{
874
  Elf_Internal_Shdr *symtab_hdr;
875
  struct elf_link_hash_entry **sym_hashes;
876
  Elf_Internal_Rela *rel, *relend;
877
 
878
  if (info->relocatable)
879
    return TRUE;
880
 
881
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
882
  sym_hashes = elf_sym_hashes (input_bfd);
883
 
884
  rel = relocs;
885
  relend = relocs + input_section->reloc_count;
886
  for (; rel < relend; rel++)
887
    {
888
      int r_type;
889
      reloc_howto_type *howto;
890
      unsigned long r_symndx;
891
      Elf_Internal_Sym *sym;
892
      asection *sec;
893
      struct elf_link_hash_entry *h;
894
      bfd_vma relocation;
895
      bfd_reloc_status_type r;
896
 
897
      r_symndx = ELF32_R_SYM (rel->r_info);
898
      r_type = ELF32_R_TYPE (rel->r_info);
899
      howto = cr16_elf_howto_table + (r_type);
900
 
901
      h = NULL;
902
      sym = NULL;
903
      sec = NULL;
904
      if (r_symndx < symtab_hdr->sh_info)
905
        {
906
          sym = local_syms + r_symndx;
907
          sec = local_sections[r_symndx];
908
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
909
        }
910
      else
911
        {
912
          bfd_boolean unresolved_reloc, warned;
913
 
914
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
915
                                   r_symndx, symtab_hdr, sym_hashes,
916
                                   h, sec, relocation,
917
                                   unresolved_reloc, warned);
918
        }
919
 
920
      r = cr16_elf_final_link_relocate (howto, input_bfd, output_bfd,
921
                                        input_section,
922
                                        contents, rel->r_offset,
923
                                        relocation, rel->r_addend,
924
                                        info, sec, h == NULL);
925
 
926
      if (r != bfd_reloc_ok)
927
        {
928
          const char *name;
929
          const char *msg = NULL;
930
 
931
          if (h != NULL)
932
            name = h->root.root.string;
933
          else
934
            {
935
              name = (bfd_elf_string_from_elf_section
936
                      (input_bfd, symtab_hdr->sh_link, sym->st_name));
937
              if (name == NULL || *name == '\0')
938
                name = bfd_section_name (input_bfd, sec);
939
            }
940
 
941
          switch (r)
942
            {
943
             case bfd_reloc_overflow:
944
               if (!((*info->callbacks->reloc_overflow)
945
                     (info, (h ? &h->root : NULL), name, howto->name,
946
                      (bfd_vma) 0, input_bfd, input_section,
947
                      rel->r_offset)))
948
                 return FALSE;
949
               break;
950
 
951
             case bfd_reloc_undefined:
952
               if (!((*info->callbacks->undefined_symbol)
953
                     (info, name, input_bfd, input_section,
954
                      rel->r_offset, TRUE)))
955
                 return FALSE;
956
               break;
957
 
958
             case bfd_reloc_outofrange:
959
               msg = _("internal error: out of range error");
960
               goto common_error;
961
 
962
             case bfd_reloc_notsupported:
963
               msg = _("internal error: unsupported relocation error");
964
               goto common_error;
965
 
966
             case bfd_reloc_dangerous:
967
               msg = _("internal error: dangerous error");
968
               goto common_error;
969
 
970
             default:
971
               msg = _("internal error: unknown error");
972
               /* Fall through.  */
973
 
974
             common_error:
975
               if (!((*info->callbacks->warning)
976
                     (info, msg, name, input_bfd, input_section,
977
                      rel->r_offset)))
978
                 return FALSE;
979
               break;
980
            }
981
        }
982
    }
983
 
984
  return TRUE;
985
}
986
 
987
/* This is a version of bfd_generic_get_relocated_section_contents
988
   which uses elf32_cr16_relocate_section.  */
989
 
990
static bfd_byte *
991
elf32_cr16_get_relocated_section_contents (bfd *output_bfd,
992
                                           struct bfd_link_info *link_info,
993
                                           struct bfd_link_order *link_order,
994
                                           bfd_byte *data,
995
                                           bfd_boolean relocatable,
996
                                           asymbol **symbols)
997
{
998
  Elf_Internal_Shdr *symtab_hdr;
999
  asection *input_section = link_order->u.indirect.section;
1000
  bfd *input_bfd = input_section->owner;
1001
  asection **sections = NULL;
1002
  Elf_Internal_Rela *internal_relocs = NULL;
1003
  Elf_Internal_Sym *isymbuf = NULL;
1004
 
1005
  /* We only need to handle the case of relaxing, or of having a
1006
     particular set of section contents, specially.  */
1007
  if (relocatable
1008
      || elf_section_data (input_section)->this_hdr.contents == NULL)
1009
    return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1010
                                                       link_order, data,
1011
                                                       relocatable,
1012
                                                       symbols);
1013
 
1014
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1015
 
1016
  memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1017
          (size_t) input_section->size);
1018
 
1019
  if ((input_section->flags & SEC_RELOC) != 0
1020
      && input_section->reloc_count > 0)
1021
    {
1022
      Elf_Internal_Sym *isym;
1023
      Elf_Internal_Sym *isymend;
1024
      asection **secpp;
1025
      bfd_size_type amt;
1026
 
1027
      internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
1028
                                                   NULL, NULL, FALSE);
1029
      if (internal_relocs == NULL)
1030
        goto error_return;
1031
 
1032
      if (symtab_hdr->sh_info != 0)
1033
        {
1034
          isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1035
          if (isymbuf == NULL)
1036
            isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1037
                                            symtab_hdr->sh_info, 0,
1038
                                            NULL, NULL, NULL);
1039
          if (isymbuf == NULL)
1040
            goto error_return;
1041
        }
1042
 
1043
      amt = symtab_hdr->sh_info;
1044
      amt *= sizeof (asection *);
1045
      sections = bfd_malloc (amt);
1046
      if (sections == NULL && amt != 0)
1047
        goto error_return;
1048
 
1049
      isymend = isymbuf + symtab_hdr->sh_info;
1050
      for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1051
        {
1052
          asection *isec;
1053
 
1054
          if (isym->st_shndx == SHN_UNDEF)
1055
            isec = bfd_und_section_ptr;
1056
          else if (isym->st_shndx == SHN_ABS)
1057
            isec = bfd_abs_section_ptr;
1058
          else if (isym->st_shndx == SHN_COMMON)
1059
            isec = bfd_com_section_ptr;
1060
          else
1061
            isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1062
 
1063
          *secpp = isec;
1064
        }
1065
 
1066
      if (! elf32_cr16_relocate_section (output_bfd, link_info, input_bfd,
1067
                                     input_section, data, internal_relocs,
1068
                                     isymbuf, sections))
1069
        goto error_return;
1070
 
1071
      if (sections != NULL)
1072
        free (sections);
1073
      if (isymbuf != NULL
1074
          && symtab_hdr->contents != (unsigned char *) isymbuf)
1075
        free (isymbuf);
1076
      if (elf_section_data (input_section)->relocs != internal_relocs)
1077
        free (internal_relocs);
1078
    }
1079
 
1080
  return data;
1081
 
1082
 error_return:
1083
  if (sections != NULL)
1084
    free (sections);
1085
  if (isymbuf != NULL
1086
      && symtab_hdr->contents != (unsigned char *) isymbuf)
1087
    free (isymbuf);
1088
  if (internal_relocs != NULL
1089
      && elf_section_data (input_section)->relocs != internal_relocs)
1090
    free (internal_relocs);
1091
  return NULL;
1092
}
1093
 
1094
/* This function handles relaxing for the CR16.
1095
 
1096
   There's quite a few relaxing opportunites available on the CR16:
1097
 
1098
        * bcond:24 -> bcond:16                                2 bytes
1099
        * bcond:16 -> bcond:8                                 2 bytes
1100
        * arithmetic imm32 -> arithmetic imm20/imm16          2 bytes
1101
        * arithmetic imm20/imm16 -> arithmetic imm4           2 bytes
1102
 
1103
   Symbol- and reloc-reading infrastructure copied from elf-m10200.c.  */
1104
 
1105
static bfd_boolean
1106
elf32_cr16_relax_section (bfd *abfd, asection *sec,
1107
                         struct bfd_link_info *link_info, bfd_boolean *again)
1108
{
1109
  Elf_Internal_Shdr *symtab_hdr;
1110
  Elf_Internal_Rela *internal_relocs;
1111
  Elf_Internal_Rela *irel, *irelend;
1112
  bfd_byte *contents = NULL;
1113
  Elf_Internal_Sym *isymbuf = NULL;
1114
 
1115
  /* Assume nothing changes.  */
1116
  *again = FALSE;
1117
 
1118
  /* We don't have to do anything for a relocatable link, if
1119
     this section does not have relocs, or if this is not a
1120
     code section.  */
1121
  if (link_info->relocatable
1122
      || (sec->flags & SEC_RELOC) == 0
1123
      || sec->reloc_count == 0
1124
      || (sec->flags & SEC_CODE) == 0)
1125
    return TRUE;
1126
 
1127
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1128
 
1129
  /* Get a copy of the native relocations.  */
1130
  internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
1131
                                               link_info->keep_memory);
1132
  if (internal_relocs == NULL)
1133
    goto error_return;
1134
 
1135
  /* Walk through them looking for relaxing opportunities.  */
1136
  irelend = internal_relocs + sec->reloc_count;
1137
  for (irel = internal_relocs; irel < irelend; irel++)
1138
    {
1139
      bfd_vma symval;
1140
 
1141
      /* If this isn't something that can be relaxed, then ignore
1142
         this reloc.  */
1143
      if (ELF32_R_TYPE (irel->r_info) != (int) R_CR16_DISP16
1144
          && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_DISP24
1145
          && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_IMM32
1146
          && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_IMM20
1147
          && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_IMM16)
1148
        continue;
1149
 
1150
      /* Get the section contents if we haven't done so already.  */
1151
      if (contents == NULL)
1152
        {
1153
          /* Get cached copy if it exists.  */
1154
          if (elf_section_data (sec)->this_hdr.contents != NULL)
1155
            contents = elf_section_data (sec)->this_hdr.contents;
1156
          /* Go get them off disk.  */
1157
          else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1158
            goto error_return;
1159
        }
1160
 
1161
      /* Read this BFD's local symbols if we haven't done so already.  */
1162
      if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1163
        {
1164
          isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1165
          if (isymbuf == NULL)
1166
            isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1167
                                            symtab_hdr->sh_info, 0,
1168
                                            NULL, NULL, NULL);
1169
          if (isymbuf == NULL)
1170
            goto error_return;
1171
        }
1172
 
1173
      /* Get the value of the symbol referred to by the reloc.  */
1174
      if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1175
        {
1176
          /* A local symbol.  */
1177
          Elf_Internal_Sym *isym;
1178
          asection *sym_sec;
1179
 
1180
          isym = isymbuf + ELF32_R_SYM (irel->r_info);
1181
          if (isym->st_shndx == SHN_UNDEF)
1182
            sym_sec = bfd_und_section_ptr;
1183
          else if (isym->st_shndx == SHN_ABS)
1184
            sym_sec = bfd_abs_section_ptr;
1185
          else if (isym->st_shndx == SHN_COMMON)
1186
            sym_sec = bfd_com_section_ptr;
1187
          else
1188
            sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1189
          symval = (isym->st_value
1190
                    + sym_sec->output_section->vma
1191
                    + sym_sec->output_offset);
1192
        }
1193
      else
1194
        {
1195
          unsigned long indx;
1196
          struct elf_link_hash_entry *h;
1197
 
1198
          /* An external symbol.  */
1199
          indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1200
          h = elf_sym_hashes (abfd)[indx];
1201
          BFD_ASSERT (h != NULL);
1202
 
1203
          if (h->root.type != bfd_link_hash_defined
1204
              && h->root.type != bfd_link_hash_defweak)
1205
            /* This appears to be a reference to an undefined
1206
               symbol.  Just ignore it--it will be caught by the
1207
               regular reloc processing.  */
1208
            continue;
1209
 
1210
          symval = (h->root.u.def.value
1211
                    + h->root.u.def.section->output_section->vma
1212
                    + h->root.u.def.section->output_offset);
1213
        }
1214
 
1215
      /* For simplicity of coding, we are going to modify the section
1216
         contents, the section relocs, and the BFD symbol table.  We
1217
         must tell the rest of the code not to free up this
1218
         information.  It would be possible to instead create a table
1219
         of changes which have to be made, as is done in coff-mips.c;
1220
         that would be more work, but would require less memory when
1221
         the linker is run.  */
1222
 
1223
      /* Try to turn a 24  branch/call into a 16bit relative
1224
         branch/call.  */
1225
      if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_DISP24)
1226
        {
1227
          bfd_vma value = symval;
1228
 
1229
          /* Deal with pc-relative gunk.  */
1230
          value -= (sec->output_section->vma + sec->output_offset);
1231
          value -= irel->r_offset;
1232
          value += irel->r_addend;
1233
 
1234
          /* See if the value will fit in 16 bits, note the high value is
1235
             0xfffe + 2 as the target will be two bytes closer if we are
1236
             able to relax.  */
1237
          if ((long) value < 0x10000 && (long) value > -0x10002)
1238
            {
1239
              unsigned int code;
1240
 
1241
              /* Get the opcode.  */
1242
              code = (unsigned int) bfd_get_32 (abfd, contents + irel->r_offset);
1243
 
1244
              /* Verify it's a 'bcond' and fix the opcode.  */
1245
              if ((code  & 0xffff) == 0x0010)
1246
                {
1247
                  bfd_put_16 (abfd, 0x1800 | ((0xf & (code >> 20)) << 4), contents + irel->r_offset);
1248
                  bfd_put_16 (abfd, value, contents + irel->r_offset + 2);
1249
                }
1250
              else
1251
                continue;
1252
 
1253
              /* Note that we've changed the relocs, section contents, etc.  */
1254
              elf_section_data (sec)->relocs = internal_relocs;
1255
              elf_section_data (sec)->this_hdr.contents = contents;
1256
              symtab_hdr->contents = (unsigned char *) isymbuf;
1257
 
1258
              /* Fix the relocation's type.  */
1259
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1260
                                           R_CR16_DISP16);
1261
 
1262
              /* Delete two bytes of data.  */
1263
              if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
1264
                                                   irel->r_offset + 2, 2))
1265
                goto error_return;
1266
 
1267
              /* That will change things, so, we should relax again.
1268
                 Note that this is not required, and it may be slow.  */
1269
              *again = TRUE;
1270
            }
1271
        }
1272
 
1273
      /* Try to turn a 16-bit pc-relative branch into an
1274
         8-bit pc-relative branch.  */
1275
      if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_DISP16)
1276
        {
1277
          bfd_vma value = symval;
1278
 
1279
          /* Deal with pc-relative gunk.  */
1280
          value -= (sec->output_section->vma + sec->output_offset);
1281
          value -= irel->r_offset;
1282
          value += irel->r_addend;
1283
 
1284
          /* See if the value will fit in 8 bits, note the high value is
1285
             0xfc + 2 as the target will be two bytes closer if we are
1286
             able to relax.  */
1287
          if ((long) value < 0xfe && (long) value > -0x100)
1288
            {
1289
              unsigned short code;
1290
 
1291
              /* Get the opcode.  */
1292
              code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1293
 
1294
              /* Verify it's a 'bcond' opcode.  */
1295
              if ((code & 0xff00) == 0x1800)
1296
                {
1297
                 bfd_put_8 (abfd, 0x1 | ((0xf & (code >> 4)) << 4), contents + irel->r_offset);
1298
                 bfd_put_8 (abfd, value, contents + irel->r_offset + 2);
1299
                }
1300
              else
1301
                continue;
1302
 
1303
              /* Note that we've changed the relocs, section contents, etc.  */
1304
              elf_section_data (sec)->relocs = internal_relocs;
1305
              elf_section_data (sec)->this_hdr.contents = contents;
1306
              symtab_hdr->contents = (unsigned char *) isymbuf;
1307
 
1308
              /* Fix the relocation's type.  */
1309
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1310
                                           R_CR16_DISP8);
1311
 
1312
              /* Delete two bytes of data.  */
1313
              if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
1314
                                                   irel->r_offset + 2, 2))
1315
                goto error_return;
1316
 
1317
              /* That will change things, so, we should relax again.
1318
                 Note that this is not required, and it may be slow.  */
1319
              *again = TRUE;
1320
            }
1321
        }
1322
 
1323
      /* Try to turn a 32bit immediate address into
1324
         a 20/16bit immediate address.  */
1325
      if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM32)
1326
        {
1327
          bfd_vma value = symval;
1328
          unsigned short is_add_mov = 0;
1329
 
1330
          /* See if the value will fit in 20 bits.  */
1331
          if ((long) value < 0xfffff && (long) value > 0)
1332
            {
1333
              unsigned short code;
1334
 
1335
              /* Get the opcode.  */
1336
              code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1337
 
1338
              /* Verify it's a arithmetic ADDD or MOVD instruction.
1339
                 For ADDD and MOVD only, convert to IMM32 -> IMM20.  */
1340
              if (((code & 0xfff0) == 0x0070) || ((code & 0xfff0) == 0x0020))
1341
                is_add_mov = 1;
1342
 
1343
              if (is_add_mov)
1344
                {
1345
                  /* Note that we've changed the relocs, section contents,
1346
                     etc.  */
1347
                  elf_section_data (sec)->relocs = internal_relocs;
1348
                  elf_section_data (sec)->this_hdr.contents = contents;
1349
                  symtab_hdr->contents = (unsigned char *) isymbuf;
1350
 
1351
                  /* Fix the opcode.  */
1352
                  if ((code & 0xfff0) == 0x0070) /* For movd.  */
1353
                    bfd_put_8 (abfd, 0x05, contents + irel->r_offset + 1);
1354
                  else                          /* code == 0x0020 for addd.  */
1355
                    bfd_put_8 (abfd, 0x04, contents + irel->r_offset + 1);
1356
 
1357
                  bfd_put_8 (abfd, (code & 0xf) << 4, contents + irel->r_offset);
1358
 
1359
 
1360
                  /* Fix the relocation's type.  */
1361
                  irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1362
                                               R_CR16_IMM20);
1363
                  /* Delete two bytes of data.  */
1364
                  if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
1365
                                                      irel->r_offset + 2, 2))
1366
                    goto error_return;
1367
 
1368
                  /* That will change things, so, we should relax again.
1369
                     Note that this is not required, and it may be slow.  */
1370
                  *again = TRUE;
1371
                }
1372
            }
1373
         /* See if the value will fit in 16 bits.  */
1374
          if ((!is_add_mov) && ((long) value < 0x7fff && (long) value > 0))
1375
            {
1376
              unsigned short code;
1377
 
1378
              /* Get the opcode.  */
1379
              code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1380
 
1381
              /* Note that we've changed the relocs, section contents, etc.  */
1382
              elf_section_data (sec)->relocs = internal_relocs;
1383
              elf_section_data (sec)->this_hdr.contents = contents;
1384
              symtab_hdr->contents = (unsigned char *) isymbuf;
1385
 
1386
              /* Fix the opcode.  */
1387
              if ((code & 0xf0) == 0x70)          /* For movd.  */
1388
                bfd_put_8 (abfd, 0x54, contents + irel->r_offset + 1);
1389
              else if ((code & 0xf0) == 0x20)     /* For addd.  */
1390
                bfd_put_8 (abfd, 0x60, contents + irel->r_offset + 1);
1391
              else if ((code & 0xf0) == 0x90)     /* For cmpd.  */
1392
                bfd_put_8 (abfd, 0x56, contents + irel->r_offset + 1);
1393
              else
1394
                continue;
1395
 
1396
              bfd_put_8 (abfd, 0xb0 | (code & 0xf), contents + irel->r_offset);
1397
 
1398
              /* Fix the relocation's type.  */
1399
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1400
                                           R_CR16_IMM16);
1401
 
1402
              /* Delete two bytes of data.  */
1403
              if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
1404
                                                  irel->r_offset + 2, 2))
1405
                 goto error_return;
1406
 
1407
              /* That will change things, so, we should relax again.
1408
                 Note that this is not required, and it may be slow.  */
1409
                 *again = TRUE;
1410
            }
1411
        }
1412
 
1413
      /* Try to turn a 20/16bit immediate address into
1414
         a 4bit immediate address.  */
1415
      if ((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM20)
1416
          || (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM16))
1417
        {
1418
          bfd_vma value = symval;
1419
 
1420
          /* See if the value will fit in 4 bits.  */
1421
          if ((long) value < 0xf && (long) value > 0)
1422
            {
1423
              unsigned short code;
1424
 
1425
              /* Get the opcode.  */
1426
              code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1427
 
1428
              /* Note that we've changed the relocs, section contents, etc.  */
1429
              elf_section_data (sec)->relocs = internal_relocs;
1430
              elf_section_data (sec)->this_hdr.contents = contents;
1431
              symtab_hdr->contents = (unsigned char *) isymbuf;
1432
 
1433
              /* Fix the opcode.  */
1434
              if (((code & 0x0f00) == 0x0400) || ((code & 0x0f00) == 0x0500))
1435
                {
1436
                  if ((code & 0x0f00) == 0x0400)      /* For movd imm20.  */
1437
                    bfd_put_8 (abfd, 0x60, contents + irel->r_offset);
1438
                  else                                /* For addd imm20.  */
1439
                    bfd_put_8 (abfd, 0x54, contents + irel->r_offset);
1440
                  bfd_put_8 (abfd, (code & 0xf0) >> 4, contents + irel->r_offset + 1);
1441
                }
1442
              else
1443
                {
1444
                  if ((code & 0xfff0) == 0x56b0)       /*  For cmpd imm16.  */
1445
                    bfd_put_8 (abfd, 0x56, contents + irel->r_offset);
1446
                  else if ((code & 0xfff0) == 0x54b0)  /*  For movd imm16.  */
1447
                    bfd_put_8 (abfd, 0x54, contents + irel->r_offset);
1448
                  else if ((code & 0xfff0) == 0x58b0)  /*  For movb imm16.  */
1449
                    bfd_put_8 (abfd, 0x58, contents + irel->r_offset);
1450
                  else if ((code & 0xfff0) == 0x5Ab0)  /*  For movw imm16.  */
1451
                    bfd_put_8 (abfd, 0x5A, contents + irel->r_offset);
1452
                  else if ((code & 0xfff0) == 0x60b0)  /*  For addd imm16.  */
1453
                    bfd_put_8 (abfd, 0x60, contents + irel->r_offset);
1454
                  else if ((code & 0xfff0) == 0x30b0)  /*  For addb imm16.  */
1455
                    bfd_put_8 (abfd, 0x30, contents + irel->r_offset);
1456
                  else if ((code & 0xfff0) == 0x2Cb0)  /*  For addub imm16.  */
1457
                    bfd_put_8 (abfd, 0x2C, contents + irel->r_offset);
1458
                  else if ((code & 0xfff0) == 0x32b0)  /*  For adduw imm16.  */
1459
                    bfd_put_8 (abfd, 0x32, contents + irel->r_offset);
1460
                  else if ((code & 0xfff0) == 0x38b0)  /*  For subb imm16.  */
1461
                    bfd_put_8 (abfd, 0x38, contents + irel->r_offset);
1462
                  else if ((code & 0xfff0) == 0x3Ab0)  /*  For subw imm16.  */
1463
                    bfd_put_8 (abfd, 0x3A, contents + irel->r_offset);
1464
                  else if ((code & 0xfff0) == 0x50b0)  /*  For cmpb imm16.  */
1465
                    bfd_put_8 (abfd, 0x50, contents + irel->r_offset);
1466
                  else if ((code & 0xfff0) == 0x52b0)  /*  For cmpw imm16.  */
1467
                    bfd_put_8 (abfd, 0x52, contents + irel->r_offset);
1468
                  else
1469
                    continue;
1470
 
1471
                  bfd_put_8 (abfd, (code & 0xf), contents + irel->r_offset + 1);
1472
                }
1473
 
1474
              /* Fix the relocation's type.  */
1475
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1476
                                           R_CR16_IMM4);
1477
 
1478
              /* Delete two bytes of data.  */
1479
              if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
1480
                                                  irel->r_offset + 2, 2))
1481
                goto error_return;
1482
 
1483
              /* That will change things, so, we should relax again.
1484
                 Note that this is not required, and it may be slow.  */
1485
              *again = TRUE;
1486
            }
1487
        }
1488
    }
1489
 
1490
  if (isymbuf != NULL
1491
      && symtab_hdr->contents != (unsigned char *) isymbuf)
1492
    {
1493
      if (! link_info->keep_memory)
1494
        free (isymbuf);
1495
      else
1496
        /* Cache the symbols for elf_link_input_bfd.  */
1497
        symtab_hdr->contents = (unsigned char *) isymbuf;
1498
    }
1499
 
1500
  if (contents != NULL
1501
      && elf_section_data (sec)->this_hdr.contents != contents)
1502
    {
1503
      if (! link_info->keep_memory)
1504
        free (contents);
1505
      else
1506
        /* Cache the section contents for elf_link_input_bfd.  */
1507
        elf_section_data (sec)->this_hdr.contents = contents;
1508
    }
1509
 
1510
  if (internal_relocs != NULL
1511
      && elf_section_data (sec)->relocs != internal_relocs)
1512
    free (internal_relocs);
1513
 
1514
  return TRUE;
1515
 
1516
 error_return:
1517
  if (isymbuf != NULL
1518
      && symtab_hdr->contents != (unsigned char *) isymbuf)
1519
    free (isymbuf);
1520
  if (contents != NULL
1521
      && elf_section_data (sec)->this_hdr.contents != contents)
1522
    free (contents);
1523
  if (internal_relocs != NULL
1524
      && elf_section_data (sec)->relocs != internal_relocs)
1525
    free (internal_relocs);
1526
 
1527
  return FALSE;
1528
}
1529
 
1530
static asection *
1531
elf32_cr16_gc_mark_hook (asection *sec,
1532
                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
1533
                         Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
1534
                         struct elf_link_hash_entry *h,
1535
                         Elf_Internal_Sym *sym)
1536
{
1537
  if (h == NULL)
1538
    return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1539
 
1540
  switch (h->root.type)
1541
    {
1542
      case bfd_link_hash_defined:
1543
      case bfd_link_hash_defweak:
1544
        return h->root.u.def.section;
1545
 
1546
      case bfd_link_hash_common:
1547
        return h->root.u.c.p->section;
1548
 
1549
      default:
1550
        return NULL;
1551
    }
1552
}
1553
 
1554
/* Update the got entry reference counts for the section being removed.  */
1555
 
1556
static bfd_boolean
1557
elf32_cr16_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
1558
                          struct bfd_link_info *info ATTRIBUTE_UNUSED,
1559
                          asection *sec ATTRIBUTE_UNUSED,
1560
                          const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
1561
{
1562
  /* We don't support garbage collection of GOT and PLT relocs yet.  */
1563
  return TRUE;
1564
}
1565
 
1566
/* Definitions for setting CR16 target vector.  */
1567
#define TARGET_LITTLE_SYM                 bfd_elf32_cr16_vec
1568
#define TARGET_LITTLE_NAME                "elf32-cr16"
1569
#define ELF_ARCH                          bfd_arch_cr16
1570
#define ELF_MACHINE_CODE                  EM_CR16
1571
#define ELF_MAXPAGESIZE                   0x1
1572
#define elf_symbol_leading_char           '_'
1573
 
1574
#define bfd_elf32_bfd_reloc_type_lookup   elf_cr16_reloc_type_lookup
1575
#define bfd_elf32_bfd_reloc_name_lookup   elf_cr16_reloc_name_lookup
1576
#define elf_info_to_howto                 elf_cr16_info_to_howto
1577
#define elf_info_to_howto_rel             0
1578
#define elf_backend_relocate_section      elf32_cr16_relocate_section
1579
#define bfd_elf32_bfd_relax_section       elf32_cr16_relax_section
1580
#define bfd_elf32_bfd_get_relocated_section_contents \
1581
                                elf32_cr16_get_relocated_section_contents
1582
#define elf_backend_gc_mark_hook          elf32_cr16_gc_mark_hook
1583
#define elf_backend_gc_sweep_hook         elf32_cr16_gc_sweep_hook
1584
#define elf_backend_can_gc_sections       1
1585
#define elf_backend_rela_normal           1
1586
 
1587
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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