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