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