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