projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bfd target vector rationalisation
[deliverable/binutils-gdb.git] / bfd / elf32-cr16c.c
1 /* BFD back-end for National Semiconductor's CR16C ELF
2 Copyright (C) 2004-2014 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
208 unsigned long disp20_opcod;
209 char neg = 0;
210 char neg2pos = 0;
211
212 long left_val = 0;
213 long plus_factor = 0; /* To be added to the hole. */
214
215 #define MIN_BYTE ((int) 0xFFFFFF80)
216 #define MIN_WORD ((int) 0xFFFF8000)
217 #define MAX_UWORD ((unsigned) 0x0000FFFF)
218 #define MAX_UBYTE ((unsigned) 0x000000FF)
219
220 r_type = reloc_map_index[howto->type].cr_reloc_type;
221 format = r_type & R_FORMAT;
222 size = r_type & R_SIZESP;
223 addr_type = r_type & R_ADDRTYPE;
224 code_factor = ((addr_type == R_CODE_ADDR) ? 1 : 0);
225
226 switch (format)
227 {
228 case R_NUMBER:
229 switch (size)
230 {
231 case R_S_16C_08: /* One byte. */
232 value = bfd_get_8 (abfd, (char *) data + octets);
233 break;
234 case R_S_16C_16: /* Two bytes. */
235 sword = bfd_get_16 (abfd, (bfd_byte *) data + octets);
236 value = sword;
237 break;
238 case R_S_16C_32: /* Four bytes. */
239 value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
240 break;
241 default:
242 return bfd_reloc_notsupported;
243 }
244 break;
245
246 case R_16C_DISPL:
247 switch (size)
248 {
249 case R_S_16C_04: /* word1(4-7). */
250 value = bfd_get_8 (abfd, (char *) data + octets);
251 left_val = value & 0xF;
252 value = (value & 0xF0) >> 4;
253 value++;
254 value <<= 1;
255 break;
256 case R_S_16C_08: /* word1(0-3,8-11). */
257 sword = bfd_get_16 (abfd, (char *) data + octets);
258 value = sword & 0x000F;
259 value |= ((sword & 0x0F00) >> 4);
260 left_val = sword & 0xF0F0;
261 value <<= 1;
262 if (value & 0x100)
263 value |= 0xFFFFFF00;
264 break;
265 case R_S_16C_16: /* word2. */
266 sword = bfd_get_16 (abfd, (bfd_byte *) data + octets);
267 value = sword;
268 value = ((value & 0xFFFE) >> 1) | ((value & 0x1) << 15);
269 value <<= 1;
270 if (value & 0x10000)
271 value |= 0xFFFF0000;
272 break;
273 case R_S_16C_24_a: /* word1(0-7),word2. */
274 value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
275 left_val = value & 0x0000FF00;
276 value = ((value & 0xFFFE0000) >> 17) |
277 ((value & 0x00010000) << 7) | ((value & 0x000000FF) << 15);
278 value <<= 1;
279 if (value & 0x1000000)
280 value |= 0xFE000000;
281 break;
282 case R_S_16C_24: /* word2(0-3,8-11),word3. */
283 value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
284 left_val = value & 0x0000F0F0;
285 value = ((value >> 16) & 0x0000FFFF) |
286 ((value & 0x00000F00) << 8) | ((value & 0x0000000F) << 20);
287
288 value = ((value & 0x00FFFFFE) >> 1) | ((value & 0x00000001) << 23);
289
290 value <<= 1;
291 if (value & 0x1000000)
292 value |= 0xFE000000;
293 break;
294 default:
295 return bfd_reloc_notsupported;
296 }
297 break;
298
299 case R_16C_REGREL:
300 switch (size)
301 {
302 case R_S_16C_04: /* word1(12-15) not scaled. */
303 value = bfd_get_8 (abfd, (char *) data + octets);
304 left_val = value & 0xF0;
305 value = value & 0xF;
306 break;
307 case R_S_16C_04_a: /* word1(12-15) scaled by 2. */
308 value = bfd_get_8 (abfd, (char *) data + octets);
309 left_val = value & 0xF0;
310 value = value & 0xF;
311 value <<= 1;
312 break;
313 case R_S_16C_14: /* word1(4-5),word2(0-3,8-15). */
314 value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
315 left_val = value & 0x00F0FFCF;
316 value = ((value & 0xc0000000) >> 24) |
317 ((value & 0x3F000000) >> 16) |
318 ((value & 0x000F0000) >> 16) | (value & 0x00000030);
319 break;
320 case R_S_16C_16: /* word2. */
321 sword = bfd_get_16 (abfd, (bfd_byte *) data + octets);
322 value = sword;
323 break;
324 case R_S_16C_20: /* word2(8-11),word3. */
325 value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
326 left_val = value & 0xF0;
327 value = (value & 0xF) << 16;
328 sword = bfd_get_16 (abfd, (bfd_byte *) data + octets + 1);
329 value = value | (unsigned short) sword;
330 disp20_opcod = bfd_get_32 (abfd, (bfd_byte *) data + octets - 3);
331 disp20_opcod |= 0x0FFF0000;
332 if ((disp20_opcod == 0x4FFF0018) || /* loadb -disp20(reg) */
333 (disp20_opcod == 0x5FFF0018) || /* loadb -disp20(rp) */
334 (disp20_opcod == 0x8FFF0018) || /* loadd -disp20(reg) */
335 (disp20_opcod == 0x9FFF0018) || /* loadd -disp20(rp) */
336 (disp20_opcod == 0xCFFF0018) || /* loadw -disp20(reg) */
337 (disp20_opcod == 0xDFFF0018) || /* loadw -disp20(rp) */
338 (disp20_opcod == 0x4FFF0019) || /* storb -disp20(reg) */
339 (disp20_opcod == 0x5FFF0019) || /* storb -disp20(rp) */
340 (disp20_opcod == 0x8FFF0019) || /* stord -disp20(reg) */
341 (disp20_opcod == 0x9FFF0019) || /* stord -disp20(rp) */
342 (disp20_opcod == 0xCFFF0019) || /* storw -disp20(reg) */
343 (disp20_opcod == 0xDFFF0019))
344 { /* storw -disp20(rp). */
345 neg = 1;
346 value |= 0xFFF00000;
347 }
348
349 break;
350 default:
351 return bfd_reloc_notsupported;
352 }
353 break;
354
355 case R_16C_ABS:
356 switch (size)
357 {
358 case R_S_16C_20: /* word1(0-3),word2. */
359 value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
360 left_val = value & 0x0000FFF0;
361 value = ((value & 0xFFFF0000) >> 16) |
362 ((value & 0x0000000F) << 16);
363 break;
364 case R_S_16C_24: /* word2(0-3,8-11),word3. */
365 value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
366 left_val = value & 0x0000F0F0;
367 value = ((value & 0xFFFF0000) >> 16) |
368 ((value & 0x00000F00) << 8) | ((value & 0x0000000F) << 20);
369 break;
370 default:
371 return bfd_reloc_notsupported;
372 }
373 break;
374
375 case R_16C_IMMED:
376 switch (size)
377 {
378 case R_S_16C_04: /* word1/2(4-7). */
379 value = bfd_get_8 (abfd, (char *) data + octets);
380 left_val = value & 0xF;
381 value = (value & 0xF0) >> 4;
382 break;
383 case R_S_16C_16: /* word2. */
384 sword = bfd_get_16 (abfd, (bfd_byte *) data + octets);
385 value = sword;
386 break;
387 case R_S_16C_20: /* word1(0-3),word2. */
388 value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
389 left_val = value & 0x0000FFF0;
390 value = ((value & 0xFFFF0000) >> 16) |
391 ((value & 0x0000000F) << 16);
392 break;
393 case R_S_16C_32: /* word2, word3. */
394 value = bfd_get_32 (abfd, (bfd_byte *) data + octets);
395 value = ((value & 0x0000FFFF) << 16) |
396 ((value & 0xFFFF0000) >> 16);
397 break;
398 default:
399 return bfd_reloc_notsupported;
400 }
401 break;
402 default:
403 return bfd_reloc_notsupported;
404 }
405
406 switch ((r_type & R_RELTO) >> 4)
407 {
408
409 case 0: /* R_ABS. */
410 plus_factor = Rvalue;
411 break;
412 case 1: /* R_PCREL. */
413 plus_factor = Rvalue -
414 (input_section->output_section->vma + input_section->output_offset);
415 break;
416 default:
417 return bfd_reloc_notsupported;
418 }
419
420 if (neg)
421 {
422 if (plus_factor >= -value)
423 neg2pos = 1;
424 /* We need to change load/stor with negative
425 displ opcode to positive disp opcode (CR16C). */
426 }
427
428 value = value + (plus_factor >> code_factor);
429
430 switch (format)
431 {
432 case R_NUMBER:
433 switch (size)
434 {
435 case R_S_16C_08: /* One byte. */
436 if (value > (int) MAX_UBYTE || value < MIN_BYTE)
437 return bfd_reloc_overflow;
438 value &= 0xFF;
439 bfd_put_8 (abfd, (bfd_vma) value, (unsigned char *) data + octets);
440 break;
441
442 case R_S_16C_16: /* Two bytes. */
443 if (value > (int) MAX_UWORD || value < MIN_WORD)
444 return bfd_reloc_overflow;
445 value &= 0xFFFF;
446 sword = value;
447 bfd_put_16 (abfd, (bfd_vma) sword,
448 (unsigned char *) data + octets);
449 break;
450
451 case R_S_16C_32: /* Four bytes. */
452 value &= 0xFFFFFFFF;
453 bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
454 break;
455
456 default:
457 return bfd_reloc_notsupported;
458 }
459 break;
460
461 case R_16C_DISPL:
462 switch (size)
463 {
464 case R_S_16C_04: /* word1(4-7). */
465 if ((value - 32) > 32 || value < 2)
466 return bfd_reloc_overflow;
467 value >>= 1;
468 value--;
469 value &= 0xF;
470 value <<= 4;
471 value |= left_val;
472 bfd_put_8 (abfd, (bfd_vma) value, (unsigned char *) data + octets);
473 break;
474
475 case R_S_16C_08: /* word1(0-3,8-11). */
476 if (value > 255 || value < -256 || value == 0x80)
477 return bfd_reloc_overflow;
478 value &= 0x1FF;
479 value >>= 1;
480 sword = value & 0x000F;
481 sword |= (value & 0x00F0) << 4;
482 sword |= left_val;
483 bfd_put_16 (abfd, (bfd_vma) sword,
484 (unsigned char *) data + octets);
485 break;
486
487 case R_S_16C_16: /* word2. */
488 if (value > 65535 || value < -65536)
489 return bfd_reloc_overflow;
490 value >>= 1;
491 value &= 0xFFFF;
492 value = ((value & 0x8000) >> 15) | ((value & 0x7FFF) << 1);
493 sword = value;
494 bfd_put_16 (abfd, (bfd_vma) sword,
495 (unsigned char *) data + octets);
496 break;
497
498 case R_S_16C_24_a: /* word1(0-7),word2. */
499 if (value > 16777215 || value < -16777216)
500 return bfd_reloc_overflow;
501 value &= 0x1FFFFFF;
502 value >>= 1;
503 value = ((value & 0x00007FFF) << 17) |
504 ((value & 0x00800000) >> 7) | ((value & 0x007F8000) >> 15);
505 value |= left_val;
506 bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
507 break;
508
509 case R_S_16C_24: /* word2(0-3,8-11),word3. */
510 if (value > 16777215 || value < -16777216)
511 return bfd_reloc_overflow;
512 value &= 0x1FFFFFF;
513 value >>= 1;
514
515 value = ((value & 0x007FFFFF) << 1) | ((value & 0x00800000) >> 23);
516
517 value = ((value & 0x0000FFFF) << 16) |
518 ((value & 0x000F0000) >> 8) | ((value & 0x00F00000) >> 20);
519 value |= left_val;
520 bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
521 break;
522
523 default:
524 return bfd_reloc_notsupported;
525 }
526 break;
527
528 case R_16C_REGREL:
529 switch (size)
530 {
531 case R_S_16C_04: /* word1(12-15) not scaled. */
532 if (value > 13 || value < 0)
533 return bfd_reloc_overflow;
534 value &= 0xF;
535 value |= left_val;
536 bfd_put_8 (abfd, (bfd_vma) value, (unsigned char *) data + octets);
537 break;
538
539 case R_S_16C_04_a: /* word1(12-15) not scaled. */
540 if (value > 26 || value < 0)
541 return bfd_reloc_overflow;
542 value &= 0x1F;
543 value >>= 1;
544 value |= left_val;
545 bfd_put_8 (abfd, (bfd_vma) value, (unsigned char *) data + octets);
546 break;
547
548 case R_S_16C_14: /* word1(4-5),word2(0-3,8-15). */
549 if (value < 0 || value > 16383)
550 return bfd_reloc_overflow;
551 value &= 0x3FFF;
552 value = ((value & 0x000000c0) << 24) |
553 ((value & 0x00003F00) << 16) |
554 ((value & 0x0000000F) << 16) | (value & 0x00000030);
555 value |= left_val;
556 bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
557 break;
558
559 case R_S_16C_16: /* word2. */
560 if (value > 65535 || value < 0)
561 return bfd_reloc_overflow;
562 value &= 0xFFFF;
563 sword = value;
564 bfd_put_16 (abfd, (bfd_vma) sword,
565 (unsigned char *) data + octets);
566 break;
567
568 case R_S_16C_20: /* word2(8-11),word3. */
569 /* if (value > 1048575 || value < 0) RELOC_ERROR(1); */
570 value &= 0xFFFFF;
571 sword = value & 0x0000FFFF;
572 value = (value & 0x000F0000) >> 16;
573 value |= left_val;
574 bfd_put_8 (abfd, (bfd_vma) value, (unsigned char *) data + octets);
575 bfd_put_16 (abfd, (bfd_vma) sword,
576 (unsigned char *) data + octets + 1);
577 if (neg2pos)
578 {
579 /* Change load/stor negative displ opcode
580 to load/stor positive displ opcode. */
581 value = bfd_get_8 (abfd, (char *) data + octets - 3);
582 value &= 0xF7;
583 value |= 0x2;
584 bfd_put_8 (abfd, (bfd_vma) value,
585 (unsigned char *) data + octets - 3);
586 }
587 break;
588
589 default:
590 return bfd_reloc_notsupported;
591 }
592 break;
593
594 case R_16C_ABS:
595 switch (size)
596 {
597 case R_S_16C_20: /* word1(0-3),word2. */
598 if (value > 1048575 || value < 0)
599 return bfd_reloc_overflow;
600 value &= 0xFFFFF;
601 value = ((value & 0x0000FFFF) << 16) |
602 ((value & 0x000F0000) >> 16);
603 value |= left_val;
604 bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
605 break;
606
607 case R_S_16C_24: /* word2(0-3,8-11),word3. */
608 /* if (value > 16777215 || value < 0) RELOC_ERROR(1); */
609 value &= 0xFFFFFF;
610 value = ((value & 0x0000FFFF) << 16) |
611 ((value & 0x000F0000) >> 8) | ((value & 0x00F00000) >> 20);
612 value |= left_val;
613 bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
614 break;
615
616 default:
617 return bfd_reloc_notsupported;
618 }
619 break;
620
621 case R_16C_IMMED:
622 switch (size)
623 {
624 case R_S_16C_04: /* word1/2(4-7). */
625 if (value > 15 || value < -1)
626 return bfd_reloc_overflow;
627 value &= 0xF;
628 value <<= 4;
629 value |= left_val;
630 bfd_put_8 (abfd, (bfd_vma) value, (unsigned char *) data + octets);
631 break;
632
633 case R_S_16C_16: /* word2. */
634 if (value > 32767 || value < -32768)
635 return bfd_reloc_overflow;
636 value &= 0xFFFF;
637 sword = value;
638 bfd_put_16 (abfd, (bfd_vma) sword,
639 (unsigned char *) data + octets);
640 break;
641
642 case R_S_16C_20: /* word1(0-3),word2. */
643 if (value > 1048575 || value < 0)
644 return bfd_reloc_overflow;
645 value &= 0xFFFFF;
646 value = ((value & 0x0000FFFF) << 16) |
647 ((value & 0x000F0000) >> 16);
648 value |= left_val;
649 bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
650 break;
651
652 case R_S_16C_32: /* word2, word3. */
653 value &= 0xFFFFFFFF;
654 value = ((value & 0x0000FFFF) << 16) |
655 ((value & 0xFFFF0000) >> 16);
656 bfd_put_32 (abfd, (bfd_vma) value, (bfd_byte *) data + octets);
657 break;
658
659 default:
660 return bfd_reloc_notsupported;
661 }
662 break;
663 default:
664 return bfd_reloc_notsupported;
665 }
666
667 return bfd_reloc_ok;
668 }
669
670 /* Relocate a CR16C ELF section. */
671
672 static bfd_boolean
673 elf32_cr16c_relocate_section (bfd *output_bfd,
674 struct bfd_link_info *info,
675 bfd *input_bfd,
676 asection *input_section,
677 bfd_byte *contents,
678 Elf_Internal_Rela *relocs,
679 Elf_Internal_Sym *local_syms,
680 asection **local_sections)
681 {
682 Elf_Internal_Shdr *symtab_hdr;
683 struct elf_link_hash_entry **sym_hashes;
684 Elf_Internal_Rela *rel, *relend;
685
686 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
687 sym_hashes = elf_sym_hashes (input_bfd);
688
689 rel = relocs;
690 relend = relocs + input_section->reloc_count;
691 for (; rel < relend; rel++)
692 {
693 int r_type;
694 reloc_howto_type *howto;
695 unsigned long r_symndx;
696 Elf_Internal_Sym *sym;
697 asection *sec;
698 struct elf_link_hash_entry *h;
699 bfd_vma relocation;
700 bfd_reloc_status_type r;
701
702 r_symndx = ELF32_R_SYM (rel->r_info);
703 r_type = ELF32_R_TYPE (rel->r_info);
704 howto = elf_howto_table + r_type;
705
706 h = NULL;
707 sym = NULL;
708 sec = NULL;
709 if (r_symndx < symtab_hdr->sh_info)
710 {
711 sym = local_syms + r_symndx;
712 sec = local_sections[r_symndx];
713 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
714 }
715 else
716 {
717 bfd_boolean unresolved_reloc, warned, ignored;
718
719 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
720 r_symndx, symtab_hdr, sym_hashes,
721 h, sec, relocation,
722 unresolved_reloc, warned, ignored);
723 }
724
725 if (sec != NULL && discarded_section (sec))
726 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
727 rel, 1, relend, howto, 0, contents);
728
729 if (info->relocatable)
730 {
731 /* This is a relocatable link. We don't have to change
732 anything, unless the reloc is against a section symbol,
733 in which case we have to adjust according to where the
734 section symbol winds up in the output section. */
735 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
736 rel->r_addend += sec->output_offset;
737 continue;
738 }
739
740 r = cr16c_elf_final_link_relocate (howto, input_bfd, output_bfd,
741 input_section,
742 contents, rel->r_offset,
743 relocation, rel->r_addend,
744 info, sec, h == NULL);
745
746 if (r != bfd_reloc_ok)
747 {
748 const char *name;
749 const char *msg = (const char *) 0;
750
751 if (h != NULL)
752 name = h->root.root.string;
753 else
754 {
755 name = (bfd_elf_string_from_elf_section
756 (input_bfd, symtab_hdr->sh_link, sym->st_name));
757 if (name == NULL || *name == '\0')
758 name = bfd_section_name (input_bfd, sec);
759 }
760
761 switch (r)
762 {
763 case bfd_reloc_overflow:
764 if (!((*info->callbacks->reloc_overflow)
765 (info, (h ? &h->root : NULL), name, howto->name,
766 (bfd_vma) 0, input_bfd, input_section,
767 rel->r_offset)))
768 return FALSE;
769 break;
770
771 case bfd_reloc_undefined:
772 if (!((*info->callbacks->undefined_symbol)
773 (info, name, input_bfd, input_section,
774 rel->r_offset, TRUE)))
775 return FALSE;
776 break;
777
778 case bfd_reloc_outofrange:
779 msg = _("internal error: out of range error");
780 goto common_error;
781
782 case bfd_reloc_notsupported:
783 msg = _("internal error: unsupported relocation error");
784 goto common_error;
785
786 case bfd_reloc_dangerous:
787 msg = _("internal error: dangerous error");
788 goto common_error;
789
790 default:
791 msg = _("internal error: unknown error");
792 /* fall through */
793
794 common_error:
795 if (!((*info->callbacks->warning)
796 (info, msg, name, input_bfd, input_section,
797 rel->r_offset)))
798 return FALSE;
799 break;
800 }
801 }
802 }
803
804 return TRUE;
805 }
806
807 /* CR16C ELF uses three common sections:
808 One is for default common symbols (placed in usual common section).
809 Second is for near common symbols (placed in "ncommon" section).
810 Third is for far common symbols (placed in "fcommon" section).
811 The following implementation is based on elf32-mips architecture */
812
813 static asection cr16c_elf_fcom_section;
814 static asymbol cr16c_elf_fcom_symbol;
815 static asymbol * cr16c_elf_fcom_symbol_ptr;
816 static asection cr16c_elf_ncom_section;
817 static asymbol cr16c_elf_ncom_symbol;
818 static asymbol * cr16c_elf_ncom_symbol_ptr;
819
820 /* Given a BFD section, try to locate the
821 corresponding ELF section index. */
822
823 static bfd_boolean
824 elf32_cr16c_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
825 asection *sec,
826 int *retval)
827 {
828 if (strcmp (bfd_get_section_name (abfd, sec), ".fcommon") == 0)
829 *retval = SHN_CR16C_FCOMMON;
830 else if (strcmp (bfd_get_section_name (abfd, sec), ".ncommon") == 0)
831 *retval = SHN_CR16C_NCOMMON;
832 else
833 return FALSE;
834
835 return TRUE;
836 }
837
838 /* Handle the special CR16C section numbers that a symbol may use. */
839
840 static void
841 elf32_cr16c_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
842 asymbol *asym)
843 {
844 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
845 unsigned int indx;
846
847 indx = elfsym->internal_elf_sym.st_shndx;
848
849 switch (indx)
850 {
851 case SHN_CR16C_FCOMMON:
852 if (cr16c_elf_fcom_section.name == NULL)
853 {
854 /* Initialize the far common section. */
855 cr16c_elf_fcom_section.name = ".fcommon";
856 cr16c_elf_fcom_section.flags = SEC_IS_COMMON | SEC_ALLOC;
857 cr16c_elf_fcom_section.output_section = &cr16c_elf_fcom_section;
858 cr16c_elf_fcom_section.symbol = &cr16c_elf_fcom_symbol;
859 cr16c_elf_fcom_section.symbol_ptr_ptr = &cr16c_elf_fcom_symbol_ptr;
860 cr16c_elf_fcom_symbol.name = ".fcommon";
861 cr16c_elf_fcom_symbol.flags = BSF_SECTION_SYM;
862 cr16c_elf_fcom_symbol.section = &cr16c_elf_fcom_section;
863 cr16c_elf_fcom_symbol_ptr = &cr16c_elf_fcom_symbol;
864 }
865 asym->section = &cr16c_elf_fcom_section;
866 asym->value = elfsym->internal_elf_sym.st_size;
867 break;
868 case SHN_CR16C_NCOMMON:
869 if (cr16c_elf_ncom_section.name == NULL)
870 {
871 /* Initialize the far common section. */
872 cr16c_elf_ncom_section.name = ".ncommon";
873 cr16c_elf_ncom_section.flags = SEC_IS_COMMON | SEC_ALLOC;
874 cr16c_elf_ncom_section.output_section = &cr16c_elf_ncom_section;
875 cr16c_elf_ncom_section.symbol = &cr16c_elf_ncom_symbol;
876 cr16c_elf_ncom_section.symbol_ptr_ptr = &cr16c_elf_ncom_symbol_ptr;
877 cr16c_elf_ncom_symbol.name = ".ncommon";
878 cr16c_elf_ncom_symbol.flags = BSF_SECTION_SYM;
879 cr16c_elf_ncom_symbol.section = &cr16c_elf_ncom_section;
880 cr16c_elf_ncom_symbol_ptr = &cr16c_elf_ncom_symbol;
881 }
882 asym->section = &cr16c_elf_ncom_section;
883 asym->value = elfsym->internal_elf_sym.st_size;
884 break;
885 }
886 }
887
888 /* Hook called by the linker routine which adds symbols from an object
889 file. We must handle the special cr16c section numbers here. */
890
891 static bfd_boolean
892 elf32_cr16c_add_symbol_hook (bfd *abfd,
893 struct bfd_link_info *info ATTRIBUTE_UNUSED,
894 Elf_Internal_Sym *sym,
895 const char **namep ATTRIBUTE_UNUSED,
896 flagword *flagsp ATTRIBUTE_UNUSED,
897 asection **secp,
898 bfd_vma *valp)
899 {
900 unsigned int indx = sym->st_shndx;
901
902 switch (indx)
903 {
904 case SHN_CR16C_FCOMMON:
905 *secp = bfd_make_section_old_way (abfd, ".fcommon");
906 (*secp)->flags |= SEC_IS_COMMON;
907 *valp = sym->st_size;
908 break;
909 case SHN_CR16C_NCOMMON:
910 *secp = bfd_make_section_old_way (abfd, ".ncommon");
911 (*secp)->flags |= SEC_IS_COMMON;
912 *valp = sym->st_size;
913 break;
914 }
915
916 return TRUE;
917 }
918
919 static int
920 elf32_cr16c_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
921 const char *name ATTRIBUTE_UNUSED,
922 Elf_Internal_Sym *sym,
923 asection *input_sec,
924 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
925 {
926 /* If we see a common symbol, which implies a relocatable link, then
927 if a symbol was in a special common section in an input file, mark
928 it as a special common in the output file. */
929
930 if (sym->st_shndx == SHN_COMMON)
931 {
932 if (strcmp (input_sec->name, ".fcommon") == 0)
933 sym->st_shndx = SHN_CR16C_FCOMMON;
934 else if (strcmp (input_sec->name, ".ncommon") == 0)
935 sym->st_shndx = SHN_CR16C_NCOMMON;
936 }
937
938 return 1;
939 }
940
941 /* Definitions for setting CR16C target vector. */
942 #define TARGET_LITTLE_SYM cr16c_elf32_vec
943 #define TARGET_LITTLE_NAME "elf32-cr16c"
944 #define ELF_ARCH bfd_arch_cr16c
945 #define ELF_MACHINE_CODE EM_CR
946 #define ELF_MAXPAGESIZE 0x1
947 #define elf_symbol_leading_char '_'
948
949 #define bfd_elf32_bfd_reloc_type_lookup elf_cr16c_reloc_type_lookup
950 #define bfd_elf32_bfd_reloc_name_lookup elf_cr16c_reloc_name_lookup
951 #define elf_info_to_howto elf_cr16c_info_to_howto
952 #define elf_info_to_howto_rel elf_cr16c_info_to_howto_rel
953 #define elf_backend_relocate_section elf32_cr16c_relocate_section
954 #define elf_backend_symbol_processing elf32_cr16c_symbol_processing
955 #define elf_backend_section_from_bfd_section elf32_cr16c_section_from_bfd_section
956 #define elf_backend_add_symbol_hook elf32_cr16c_add_symbol_hook
957 #define elf_backend_link_output_symbol_hook elf32_cr16c_link_output_symbol_hook
958
959 #define elf_backend_can_gc_sections 1
960
961 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.050517 seconds and 4 git commands to generate.