projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
unrecognized/unsupported reloc message
[deliverable/binutils-gdb.git] / bfd / elf32-cr16.c
1 /* BFD back-end for National Semiconductor's CR16 ELF
2 Copyright (C) 2007-2018 Free Software Foundation, Inc.
3 Written by M R Swami Reddy.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software Foundation,
19 Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "bfdlink.h"
24 #include "libbfd.h"
25 #include "libiberty.h"
26 #include "elf-bfd.h"
27 #include "elf/cr16.h"
28
29 /* The cr16 linker needs to keep track of the number of relocs that
30 it decides to copy in check_relocs for each symbol. This is so
31 that it can discard PC relative relocs if it doesn't need them when
32 linking with -Bsymbolic. We store the information in a field
33 extending the regular ELF linker hash table. */
34
35 struct elf32_cr16_link_hash_entry
36 {
37 /* The basic elf link hash table entry. */
38 struct elf_link_hash_entry root;
39
40 /* For function symbols, the number of times this function is
41 called directly (ie by name). */
42 unsigned int direct_calls;
43
44 /* For function symbols, the size of this function's stack
45 (if <= 255 bytes). We stuff this into "call" instructions
46 to this target when it's valid and profitable to do so.
47
48 This does not include stack allocated by movm! */
49 unsigned char stack_size;
50
51 /* For function symbols, arguments (if any) for movm instruction
52 in the prologue. We stuff this value into "call" instructions
53 to the target when it's valid and profitable to do so. */
54 unsigned char movm_args;
55
56 /* For function symbols, the amount of stack space that would be allocated
57 by the movm instruction. This is redundant with movm_args, but we
58 add it to the hash table to avoid computing it over and over. */
59 unsigned char movm_stack_size;
60
61 /* Used to mark functions which have had redundant parts of their
62 prologue deleted. */
63 #define CR16_DELETED_PROLOGUE_BYTES 0x1
64 unsigned char flags;
65
66 /* Calculated value. */
67 bfd_vma value;
68 };
69
70 /* cr16_reloc_map array maps BFD relocation enum into a CRGAS relocation type. */
71
72 struct cr16_reloc_map
73 {
74 bfd_reloc_code_real_type bfd_reloc_enum; /* BFD relocation enum. */
75 unsigned short cr16_reloc_type; /* CR16 relocation type. */
76 };
77
78 static const struct cr16_reloc_map cr16_reloc_map[R_CR16_MAX] =
79 {
80 {BFD_RELOC_NONE, R_CR16_NONE},
81 {BFD_RELOC_CR16_NUM8, R_CR16_NUM8},
82 {BFD_RELOC_CR16_NUM16, R_CR16_NUM16},
83 {BFD_RELOC_CR16_NUM32, R_CR16_NUM32},
84 {BFD_RELOC_CR16_NUM32a, R_CR16_NUM32a},
85 {BFD_RELOC_CR16_REGREL4, R_CR16_REGREL4},
86 {BFD_RELOC_CR16_REGREL4a, R_CR16_REGREL4a},
87 {BFD_RELOC_CR16_REGREL14, R_CR16_REGREL14},
88 {BFD_RELOC_CR16_REGREL14a, R_CR16_REGREL14a},
89 {BFD_RELOC_CR16_REGREL16, R_CR16_REGREL16},
90 {BFD_RELOC_CR16_REGREL20, R_CR16_REGREL20},
91 {BFD_RELOC_CR16_REGREL20a, R_CR16_REGREL20a},
92 {BFD_RELOC_CR16_ABS20, R_CR16_ABS20},
93 {BFD_RELOC_CR16_ABS24, R_CR16_ABS24},
94 {BFD_RELOC_CR16_IMM4, R_CR16_IMM4},
95 {BFD_RELOC_CR16_IMM8, R_CR16_IMM8},
96 {BFD_RELOC_CR16_IMM16, R_CR16_IMM16},
97 {BFD_RELOC_CR16_IMM20, R_CR16_IMM20},
98 {BFD_RELOC_CR16_IMM24, R_CR16_IMM24},
99 {BFD_RELOC_CR16_IMM32, R_CR16_IMM32},
100 {BFD_RELOC_CR16_IMM32a, R_CR16_IMM32a},
101 {BFD_RELOC_CR16_DISP4, R_CR16_DISP4},
102 {BFD_RELOC_CR16_DISP8, R_CR16_DISP8},
103 {BFD_RELOC_CR16_DISP16, R_CR16_DISP16},
104 {BFD_RELOC_CR16_DISP24, R_CR16_DISP24},
105 {BFD_RELOC_CR16_DISP24a, R_CR16_DISP24a},
106 {BFD_RELOC_CR16_SWITCH8, R_CR16_SWITCH8},
107 {BFD_RELOC_CR16_SWITCH16, R_CR16_SWITCH16},
108 {BFD_RELOC_CR16_SWITCH32, R_CR16_SWITCH32},
109 {BFD_RELOC_CR16_GOT_REGREL20, R_CR16_GOT_REGREL20},
110 {BFD_RELOC_CR16_GOTC_REGREL20, R_CR16_GOTC_REGREL20},
111 {BFD_RELOC_CR16_GLOB_DAT, R_CR16_GLOB_DAT}
112 };
113
114 static reloc_howto_type cr16_elf_howto_table[] =
115 {
116 HOWTO (R_CR16_NONE, /* type */
117 0, /* rightshift */
118 3, /* size */
119 0, /* bitsize */
120 FALSE, /* pc_relative */
121 0, /* bitpos */
122 complain_overflow_dont, /* complain_on_overflow */
123 bfd_elf_generic_reloc, /* special_function */
124 "R_CR16_NONE", /* name */
125 FALSE, /* partial_inplace */
126 0, /* src_mask */
127 0, /* dst_mask */
128 FALSE), /* pcrel_offset */
129
130 HOWTO (R_CR16_NUM8, /* type */
131 0, /* rightshift */
132 0, /* size */
133 8, /* bitsize */
134 FALSE, /* pc_relative */
135 0, /* bitpos */
136 complain_overflow_bitfield,/* complain_on_overflow */
137 bfd_elf_generic_reloc, /* special_function */
138 "R_CR16_NUM8", /* name */
139 FALSE, /* partial_inplace */
140 0x0, /* src_mask */
141 0xff, /* dst_mask */
142 FALSE), /* pcrel_offset */
143
144 HOWTO (R_CR16_NUM16, /* type */
145 0, /* rightshift */
146 1, /* size */
147 16, /* bitsize */
148 FALSE, /* pc_relative */
149 0, /* bitpos */
150 complain_overflow_bitfield,/* complain_on_overflow */
151 bfd_elf_generic_reloc, /* special_function */
152 "R_CR16_NUM16", /* name */
153 FALSE, /* partial_inplace */
154 0x0, /* src_mask */
155 0xffff, /* dst_mask */
156 FALSE), /* pcrel_offset */
157
158 HOWTO (R_CR16_NUM32, /* type */
159 0, /* rightshift */
160 2, /* size */
161 32, /* bitsize */
162 FALSE, /* pc_relative */
163 0, /* bitpos */
164 complain_overflow_bitfield,/* complain_on_overflow */
165 bfd_elf_generic_reloc, /* special_function */
166 "R_CR16_NUM32", /* name */
167 FALSE, /* partial_inplace */
168 0x0, /* src_mask */
169 0xffffffff, /* dst_mask */
170 FALSE), /* pcrel_offset */
171
172 HOWTO (R_CR16_NUM32a, /* type */
173 1, /* rightshift */
174 2, /* size */
175 32, /* bitsize */
176 FALSE, /* pc_relative */
177 0, /* bitpos */
178 complain_overflow_bitfield,/* complain_on_overflow */
179 bfd_elf_generic_reloc, /* special_function */
180 "R_CR16_NUM32a", /* name */
181 FALSE, /* partial_inplace */
182 0x0, /* src_mask */
183 0xffffffff, /* dst_mask */
184 FALSE), /* pcrel_offset */
185
186 HOWTO (R_CR16_REGREL4, /* type */
187 0, /* rightshift */
188 0, /* size */
189 4, /* bitsize */
190 FALSE, /* pc_relative */
191 0, /* bitpos */
192 complain_overflow_bitfield,/* complain_on_overflow */
193 bfd_elf_generic_reloc, /* special_function */
194 "R_CR16_REGREL4", /* name */
195 FALSE, /* partial_inplace */
196 0x0, /* src_mask */
197 0xf, /* dst_mask */
198 FALSE), /* pcrel_offset */
199
200 HOWTO (R_CR16_REGREL4a, /* type */
201 0, /* rightshift */
202 0, /* size */
203 4, /* bitsize */
204 FALSE, /* pc_relative */
205 0, /* bitpos */
206 complain_overflow_bitfield,/* complain_on_overflow */
207 bfd_elf_generic_reloc, /* special_function */
208 "R_CR16_REGREL4a", /* name */
209 FALSE, /* partial_inplace */
210 0x0, /* src_mask */
211 0xf, /* dst_mask */
212 FALSE), /* pcrel_offset */
213
214 HOWTO (R_CR16_REGREL14, /* type */
215 0, /* rightshift */
216 1, /* size */
217 14, /* bitsize */
218 FALSE, /* pc_relative */
219 0, /* bitpos */
220 complain_overflow_bitfield,/* complain_on_overflow */
221 bfd_elf_generic_reloc, /* special_function */
222 "R_CR16_REGREL14", /* name */
223 FALSE, /* partial_inplace */
224 0x0, /* src_mask */
225 0x3fff, /* dst_mask */
226 FALSE), /* pcrel_offset */
227
228 HOWTO (R_CR16_REGREL14a, /* type */
229 0, /* rightshift */
230 1, /* size */
231 14, /* bitsize */
232 FALSE, /* pc_relative */
233 0, /* bitpos */
234 complain_overflow_bitfield,/* complain_on_overflow */
235 bfd_elf_generic_reloc, /* special_function */
236 "R_CR16_REGREL14a", /* name */
237 FALSE, /* partial_inplace */
238 0x0, /* src_mask */
239 0x3fff, /* dst_mask */
240 FALSE), /* pcrel_offset */
241
242 HOWTO (R_CR16_REGREL16, /* type */
243 0, /* rightshift */
244 1, /* size */
245 16, /* bitsize */
246 FALSE, /* pc_relative */
247 0, /* bitpos */
248 complain_overflow_bitfield,/* complain_on_overflow */
249 bfd_elf_generic_reloc, /* special_function */
250 "R_CR16_REGREL16", /* name */
251 FALSE, /* partial_inplace */
252 0x0, /* src_mask */
253 0xffff, /* dst_mask */
254 FALSE), /* pcrel_offset */
255
256 HOWTO (R_CR16_REGREL20, /* type */
257 0, /* rightshift */
258 2, /* size */
259 20, /* bitsize */
260 FALSE, /* pc_relative */
261 0, /* bitpos */
262 complain_overflow_bitfield,/* complain_on_overflow */
263 bfd_elf_generic_reloc, /* special_function */
264 "R_CR16_REGREL20", /* name */
265 FALSE, /* partial_inplace */
266 0x0, /* src_mask */
267 0xfffff, /* dst_mask */
268 FALSE), /* pcrel_offset */
269
270 HOWTO (R_CR16_REGREL20a, /* type */
271 0, /* rightshift */
272 2, /* size */
273 20, /* bitsize */
274 FALSE, /* pc_relative */
275 0, /* bitpos */
276 complain_overflow_bitfield,/* complain_on_overflow */
277 bfd_elf_generic_reloc, /* special_function */
278 "R_CR16_REGREL20a", /* name */
279 FALSE, /* partial_inplace */
280 0x0, /* src_mask */
281 0xfffff, /* dst_mask */
282 FALSE), /* pcrel_offset */
283
284 HOWTO (R_CR16_ABS20, /* type */
285 0, /* rightshift */
286 2, /* size */
287 20, /* bitsize */
288 FALSE, /* pc_relative */
289 0, /* bitpos */
290 complain_overflow_bitfield,/* complain_on_overflow */
291 bfd_elf_generic_reloc, /* special_function */
292 "R_CR16_ABS20", /* name */
293 FALSE, /* partial_inplace */
294 0x0, /* src_mask */
295 0xfffff, /* dst_mask */
296 FALSE), /* pcrel_offset */
297
298 HOWTO (R_CR16_ABS24, /* type */
299 0, /* rightshift */
300 2, /* size */
301 24, /* bitsize */
302 FALSE, /* pc_relative */
303 0, /* bitpos */
304 complain_overflow_bitfield,/* complain_on_overflow */
305 bfd_elf_generic_reloc, /* special_function */
306 "R_CR16_ABS24", /* name */
307 FALSE, /* partial_inplace */
308 0x0, /* src_mask */
309 0xffffff, /* dst_mask */
310 FALSE), /* pcrel_offset */
311
312 HOWTO (R_CR16_IMM4, /* type */
313 0, /* rightshift */
314 0, /* size */
315 4, /* bitsize */
316 FALSE, /* pc_relative */
317 0, /* bitpos */
318 complain_overflow_bitfield,/* complain_on_overflow */
319 bfd_elf_generic_reloc, /* special_function */
320 "R_CR16_IMM4", /* name */
321 FALSE, /* partial_inplace */
322 0x0, /* src_mask */
323 0xf, /* dst_mask */
324 FALSE), /* pcrel_offset */
325
326 HOWTO (R_CR16_IMM8, /* type */
327 0, /* rightshift */
328 0, /* size */
329 8, /* bitsize */
330 FALSE, /* pc_relative */
331 0, /* bitpos */
332 complain_overflow_bitfield,/* complain_on_overflow */
333 bfd_elf_generic_reloc, /* special_function */
334 "R_CR16_IMM8", /* name */
335 FALSE, /* partial_inplace */
336 0x0, /* src_mask */
337 0xff, /* dst_mask */
338 FALSE), /* pcrel_offset */
339
340 HOWTO (R_CR16_IMM16, /* type */
341 0, /* rightshift */
342 1, /* size */
343 16, /* bitsize */
344 FALSE, /* pc_relative */
345 0, /* bitpos */
346 complain_overflow_bitfield,/* complain_on_overflow */
347 bfd_elf_generic_reloc, /* special_function */
348 "R_CR16_IMM16", /* name */
349 FALSE, /* partial_inplace */
350 0x0, /* src_mask */
351 0xffff, /* dst_mask */
352 FALSE), /* pcrel_offset */
353
354 HOWTO (R_CR16_IMM20, /* type */
355 0, /* rightshift */
356 2, /* size */
357 20, /* bitsize */
358 FALSE, /* pc_relative */
359 0, /* bitpos */
360 complain_overflow_bitfield,/* complain_on_overflow */
361 bfd_elf_generic_reloc, /* special_function */
362 "R_CR16_IMM20", /* name */
363 FALSE, /* partial_inplace */
364 0x0, /* src_mask */
365 0xfffff, /* dst_mask */
366 FALSE), /* pcrel_offset */
367
368 HOWTO (R_CR16_IMM24, /* type */
369 0, /* rightshift */
370 2, /* size */
371 24, /* bitsize */
372 FALSE, /* pc_relative */
373 0, /* bitpos */
374 complain_overflow_bitfield,/* complain_on_overflow */
375 bfd_elf_generic_reloc, /* special_function */
376 "R_CR16_IMM24", /* name */
377 FALSE, /* partial_inplace */
378 0x0, /* src_mask */
379 0xffffff, /* dst_mask */
380 FALSE), /* pcrel_offset */
381
382 HOWTO (R_CR16_IMM32, /* type */
383 0, /* rightshift */
384 2, /* size */
385 32, /* bitsize */
386 FALSE, /* pc_relative */
387 0, /* bitpos */
388 complain_overflow_bitfield,/* complain_on_overflow */
389 bfd_elf_generic_reloc, /* special_function */
390 "R_CR16_IMM32", /* name */
391 FALSE, /* partial_inplace */
392 0x0, /* src_mask */
393 0xffffffff, /* dst_mask */
394 FALSE), /* pcrel_offset */
395
396 HOWTO (R_CR16_IMM32a, /* type */
397 1, /* rightshift */
398 2, /* size */
399 32, /* bitsize */
400 FALSE, /* pc_relative */
401 0, /* bitpos */
402 complain_overflow_bitfield,/* complain_on_overflow */
403 bfd_elf_generic_reloc, /* special_function */
404 "R_CR16_IMM32a", /* name */
405 FALSE, /* partial_inplace */
406 0x0, /* src_mask */
407 0xffffffff, /* dst_mask */
408 FALSE), /* pcrel_offset */
409
410 HOWTO (R_CR16_DISP4, /* type */
411 1, /* rightshift */
412 0, /* size (0 = byte, 1 = short, 2 = long) */
413 4, /* bitsize */
414 TRUE, /* pc_relative */
415 0, /* bitpos */
416 complain_overflow_unsigned, /* complain_on_overflow */
417 bfd_elf_generic_reloc, /* special_function */
418 "R_CR16_DISP4", /* name */
419 FALSE, /* partial_inplace */
420 0x0, /* src_mask */
421 0xf, /* dst_mask */
422 FALSE), /* pcrel_offset */
423
424 HOWTO (R_CR16_DISP8, /* type */
425 1, /* rightshift */
426 0, /* size (0 = byte, 1 = short, 2 = long) */
427 8, /* bitsize */
428 TRUE, /* pc_relative */
429 0, /* bitpos */
430 complain_overflow_unsigned, /* complain_on_overflow */
431 bfd_elf_generic_reloc, /* special_function */
432 "R_CR16_DISP8", /* name */
433 FALSE, /* partial_inplace */
434 0x0, /* src_mask */
435 0x1ff, /* dst_mask */
436 FALSE), /* pcrel_offset */
437
438 HOWTO (R_CR16_DISP16, /* type */
439 0, /* rightshift REVIITS: To sync with WinIDEA*/
440 1, /* size (0 = byte, 1 = short, 2 = long) */
441 16, /* bitsize */
442 TRUE, /* pc_relative */
443 0, /* bitpos */
444 complain_overflow_unsigned, /* complain_on_overflow */
445 bfd_elf_generic_reloc, /* special_function */
446 "R_CR16_DISP16", /* name */
447 FALSE, /* partial_inplace */
448 0x0, /* src_mask */
449 0x1ffff, /* dst_mask */
450 FALSE), /* pcrel_offset */
451 /* REVISIT: DISP24 should be left-shift by 2 as per ISA doc
452 but its not done, to sync with WinIDEA and CR16 4.1 tools */
453 HOWTO (R_CR16_DISP24, /* type */
454 0, /* rightshift */
455 2, /* size (0 = byte, 1 = short, 2 = long) */
456 24, /* bitsize */
457 TRUE, /* pc_relative */
458 0, /* bitpos */
459 complain_overflow_unsigned, /* complain_on_overflow */
460 bfd_elf_generic_reloc, /* special_function */
461 "R_CR16_DISP24", /* name */
462 FALSE, /* partial_inplace */
463 0x0, /* src_mask */
464 0x1ffffff, /* dst_mask */
465 FALSE), /* pcrel_offset */
466
467 HOWTO (R_CR16_DISP24a, /* type */
468 0, /* rightshift */
469 2, /* size (0 = byte, 1 = short, 2 = long) */
470 24, /* bitsize */
471 TRUE, /* pc_relative */
472 0, /* bitpos */
473 complain_overflow_unsigned, /* complain_on_overflow */
474 bfd_elf_generic_reloc, /* special_function */
475 "R_CR16_DISP24a", /* name */
476 FALSE, /* partial_inplace */
477 0x0, /* src_mask */
478 0xffffff, /* dst_mask */
479 FALSE), /* pcrel_offset */
480
481 /* An 8 bit switch table entry. This is generated for an expression
482 such as ``.byte L1 - L2''. The offset holds the difference
483 between the reloc address and L2. */
484 HOWTO (R_CR16_SWITCH8, /* type */
485 0, /* rightshift */
486 0, /* size (0 = byte, 1 = short, 2 = long) */
487 8, /* bitsize */
488 FALSE, /* pc_relative */
489 0, /* bitpos */
490 complain_overflow_unsigned, /* complain_on_overflow */
491 bfd_elf_generic_reloc, /* special_function */
492 "R_CR16_SWITCH8", /* name */
493 FALSE, /* partial_inplace */
494 0x0, /* src_mask */
495 0xff, /* dst_mask */
496 TRUE), /* pcrel_offset */
497
498 /* A 16 bit switch table entry. This is generated for an expression
499 such as ``.word L1 - L2''. The offset holds the difference
500 between the reloc address and L2. */
501 HOWTO (R_CR16_SWITCH16, /* type */
502 0, /* rightshift */
503 1, /* size (0 = byte, 1 = short, 2 = long) */
504 16, /* bitsize */
505 FALSE, /* pc_relative */
506 0, /* bitpos */
507 complain_overflow_unsigned, /* complain_on_overflow */
508 bfd_elf_generic_reloc, /* special_function */
509 "R_CR16_SWITCH16", /* name */
510 FALSE, /* partial_inplace */
511 0x0, /* src_mask */
512 0xffff, /* dst_mask */
513 TRUE), /* pcrel_offset */
514
515 /* A 32 bit switch table entry. This is generated for an expression
516 such as ``.long L1 - L2''. The offset holds the difference
517 between the reloc address and L2. */
518 HOWTO (R_CR16_SWITCH32, /* type */
519 0, /* rightshift */
520 2, /* size (0 = byte, 1 = short, 2 = long) */
521 32, /* bitsize */
522 FALSE, /* pc_relative */
523 0, /* bitpos */
524 complain_overflow_unsigned, /* complain_on_overflow */
525 bfd_elf_generic_reloc, /* special_function */
526 "R_CR16_SWITCH32", /* name */
527 FALSE, /* partial_inplace */
528 0x0, /* src_mask */
529 0xffffffff, /* dst_mask */
530 TRUE), /* pcrel_offset */
531
532 HOWTO (R_CR16_GOT_REGREL20, /* type */
533 0, /* rightshift */
534 2, /* size */
535 20, /* bitsize */
536 FALSE, /* pc_relative */
537 0, /* bitpos */
538 complain_overflow_bitfield,/* complain_on_overflow */
539 bfd_elf_generic_reloc, /* special_function */
540 "R_CR16_GOT_REGREL20", /* name */
541 TRUE, /* partial_inplace */
542 0x0, /* src_mask */
543 0xfffff, /* dst_mask */
544 FALSE), /* pcrel_offset */
545
546 HOWTO (R_CR16_GOTC_REGREL20, /* type */
547 0, /* rightshift */
548 2, /* size */
549 20, /* bitsize */
550 FALSE, /* pc_relative */
551 0, /* bitpos */
552 complain_overflow_bitfield,/* complain_on_overflow */
553 bfd_elf_generic_reloc, /* special_function */
554 "R_CR16_GOTC_REGREL20", /* name */
555 TRUE, /* partial_inplace */
556 0x0, /* src_mask */
557 0xfffff, /* dst_mask */
558 FALSE), /* pcrel_offset */
559
560 HOWTO (R_CR16_GLOB_DAT, /* type */
561 0, /* rightshift */
562 2, /* size (0 = byte, 1 = short, 2 = long) */
563 32, /* bitsize */
564 FALSE, /* pc_relative */
565 0, /* bitpos */
566 complain_overflow_unsigned, /* complain_on_overflow */
567 bfd_elf_generic_reloc, /* special_function */
568 "R_CR16_GLOB_DAT", /* name */
569 FALSE, /* partial_inplace */
570 0x0, /* src_mask */
571 0xffffffff, /* dst_mask */
572 TRUE) /* pcrel_offset */
573 };
574
575
576 /* Create the GOT section. */
577
578 static bfd_boolean
579 _bfd_cr16_elf_create_got_section (bfd * abfd, struct bfd_link_info * info)
580 {
581 flagword flags;
582 asection * s;
583 struct elf_link_hash_entry * h;
584 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
585 struct elf_link_hash_table *htab = elf_hash_table (info);
586 int ptralign;
587
588 /* This function may be called more than once. */
589 if (htab->sgot != NULL)
590 return TRUE;
591
592 switch (bed->s->arch_size)
593 {
594 case 16:
595 ptralign = 1;
596 break;
597
598 case 32:
599 ptralign = 2;
600 break;
601
602 default:
603 bfd_set_error (bfd_error_bad_value);
604 return FALSE;
605 }
606
607 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
608 | SEC_LINKER_CREATED);
609
610 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
611 htab->sgot= s;
612 if (s == NULL
613 || ! bfd_set_section_alignment (abfd, s, ptralign))
614 return FALSE;
615
616 if (bed->want_got_plt)
617 {
618 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
619 htab->sgotplt = s;
620 if (s == NULL
621 || ! bfd_set_section_alignment (abfd, s, ptralign))
622 return FALSE;
623 }
624
625 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
626 (or .got.plt) section. We don't do this in the linker script
627 because we don't want to define the symbol if we are not creating
628 a global offset table. */
629 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
630 htab->hgot = h;
631 if (h == NULL)
632 return FALSE;
633
634 /* The first bit of the global offset table is the header. */
635 s->size += bed->got_header_size;
636
637 return TRUE;
638 }
639
640
641 /* Retrieve a howto ptr using a BFD reloc_code. */
642
643 static reloc_howto_type *
644 elf_cr16_reloc_type_lookup (bfd *abfd,
645 bfd_reloc_code_real_type code)
646 {
647 unsigned int i;
648
649 for (i = 0; i < R_CR16_MAX; i++)
650 if (code == cr16_reloc_map[i].bfd_reloc_enum)
651 return &cr16_elf_howto_table[cr16_reloc_map[i].cr16_reloc_type];
652
653 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
654 abfd, code);
655 return NULL;
656 }
657
658 static reloc_howto_type *
659 elf_cr16_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
660 const char *r_name)
661 {
662 unsigned int i;
663
664 for (i = 0; ARRAY_SIZE (cr16_elf_howto_table); i++)
665 if (cr16_elf_howto_table[i].name != NULL
666 && strcasecmp (cr16_elf_howto_table[i].name, r_name) == 0)
667 return cr16_elf_howto_table + i;
668
669 return NULL;
670 }
671
672 /* Retrieve a howto ptr using an internal relocation entry. */
673
674 static void
675 elf_cr16_info_to_howto (bfd *abfd, arelent *cache_ptr,
676 Elf_Internal_Rela *dst)
677 {
678 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
679
680 if (r_type >= R_CR16_MAX)
681 {
682 /* xgettext:c-format */
683 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
684 abfd, r_type);
685 bfd_set_error (bfd_error_bad_value);
686 r_type = R_CR16_NONE;
687 }
688 cache_ptr->howto = cr16_elf_howto_table + r_type;
689 }
690
691 /* Look through the relocs for a section during the first phase.
692 Since we don't do .gots or .plts, we just need to consider the
693 virtual table relocs for gc. */
694
695 static bfd_boolean
696 cr16_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
697 const Elf_Internal_Rela *relocs)
698 {
699 Elf_Internal_Shdr *symtab_hdr;
700 Elf_Internal_Sym * isymbuf = NULL;
701 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
702 const Elf_Internal_Rela *rel;
703 const Elf_Internal_Rela *rel_end;
704 bfd * dynobj;
705 bfd_vma * local_got_offsets;
706 asection * sgot;
707 asection * srelgot;
708
709 sgot = NULL;
710 srelgot = NULL;
711 bfd_boolean result = FALSE;
712
713 if (bfd_link_relocatable (info))
714 return TRUE;
715
716 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
717 sym_hashes = elf_sym_hashes (abfd);
718 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
719 if (!elf_bad_symtab (abfd))
720 sym_hashes_end -= symtab_hdr->sh_info;
721
722 dynobj = elf_hash_table (info)->dynobj;
723 local_got_offsets = elf_local_got_offsets (abfd);
724 rel_end = relocs + sec->reloc_count;
725 for (rel = relocs; rel < rel_end; rel++)
726 {
727 struct elf_link_hash_entry *h;
728 unsigned long r_symndx;
729
730 r_symndx = ELF32_R_SYM (rel->r_info);
731 if (r_symndx < symtab_hdr->sh_info)
732 h = NULL;
733 else
734 {
735 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
736 while (h->root.type == bfd_link_hash_indirect
737 || h->root.type == bfd_link_hash_warning)
738 h = (struct elf_link_hash_entry *) h->root.u.i.link;
739 }
740
741 /* Some relocs require a global offset table. */
742 if (dynobj == NULL)
743 {
744 switch (ELF32_R_TYPE (rel->r_info))
745 {
746 case R_CR16_GOT_REGREL20:
747 case R_CR16_GOTC_REGREL20:
748 elf_hash_table (info)->dynobj = dynobj = abfd;
749 if (! _bfd_cr16_elf_create_got_section (dynobj, info))
750 goto fail;
751 break;
752
753 default:
754 break;
755 }
756 }
757
758 switch (ELF32_R_TYPE (rel->r_info))
759 {
760 case R_CR16_GOT_REGREL20:
761 case R_CR16_GOTC_REGREL20:
762 /* This symbol requires a global offset table entry. */
763
764 sgot = elf_hash_table (info)->sgot;
765 srelgot = elf_hash_table (info)->srelgot;
766 BFD_ASSERT (sgot != NULL && srelgot != NULL);
767
768 if (h != NULL)
769 {
770 if (h->got.offset != (bfd_vma) -1)
771 /* We have already allocated space in the .got. */
772 break;
773
774 h->got.offset = sgot->size;
775
776 /* Make sure this symbol is output as a dynamic symbol. */
777 if (h->dynindx == -1)
778 {
779 if (! bfd_elf_link_record_dynamic_symbol (info, h))
780 goto fail;
781 }
782
783 srelgot->size += sizeof (Elf32_External_Rela);
784 }
785 else
786 {
787 /* This is a global offset table entry for a local
788 symbol. */
789 if (local_got_offsets == NULL)
790 {
791 size_t size;
792 unsigned int i;
793
794 size = symtab_hdr->sh_info * sizeof (bfd_vma);
795 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
796
797 if (local_got_offsets == NULL)
798 goto fail;
799
800 elf_local_got_offsets (abfd) = local_got_offsets;
801
802 for (i = 0; i < symtab_hdr->sh_info; i++)
803 local_got_offsets[i] = (bfd_vma) -1;
804 }
805
806 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
807 /* We have already allocated space in the .got. */
808 break;
809
810 local_got_offsets[r_symndx] = sgot->size;
811
812 if (bfd_link_executable (info))
813 /* If we are generating a shared object, we need to
814 output a R_CR16_RELATIVE reloc so that the dynamic
815 linker can adjust this GOT entry. */
816 srelgot->size += sizeof (Elf32_External_Rela);
817 }
818
819 sgot->size += 4;
820 break;
821
822 }
823 }
824
825 result = TRUE;
826 fail:
827 if (isymbuf != NULL)
828 free (isymbuf);
829
830 return result;
831 }
832
833 /* Perform a relocation as part of a final link. */
834
835 static bfd_reloc_status_type
836 cr16_elf_final_link_relocate (reloc_howto_type *howto,
837 bfd *input_bfd,
838 bfd *output_bfd ATTRIBUTE_UNUSED,
839 asection *input_section,
840 bfd_byte *contents,
841 bfd_vma offset,
842 bfd_vma Rvalue,
843 bfd_vma addend,
844 struct elf_link_hash_entry * h,
845 unsigned long symndx ATTRIBUTE_UNUSED,
846 struct bfd_link_info *info ATTRIBUTE_UNUSED,
847 asection *sec ATTRIBUTE_UNUSED,
848 int is_local ATTRIBUTE_UNUSED)
849 {
850 unsigned short r_type = howto->type;
851 bfd_byte *hit_data = contents + offset;
852 bfd_vma reloc_bits, check, Rvalue1;
853
854 switch (r_type)
855 {
856 case R_CR16_IMM4:
857 case R_CR16_IMM20:
858 case R_CR16_ABS20:
859 break;
860
861 case R_CR16_IMM8:
862 case R_CR16_IMM16:
863 case R_CR16_IMM32:
864 case R_CR16_IMM32a:
865 case R_CR16_REGREL4:
866 case R_CR16_REGREL4a:
867 case R_CR16_REGREL14:
868 case R_CR16_REGREL14a:
869 case R_CR16_REGREL16:
870 case R_CR16_REGREL20:
871 case R_CR16_REGREL20a:
872 case R_CR16_GOT_REGREL20:
873 case R_CR16_GOTC_REGREL20:
874 case R_CR16_ABS24:
875 case R_CR16_DISP16:
876 case R_CR16_DISP24:
877 /* 'hit_data' is relative to the start of the instruction, not the
878 relocation offset. Advance it to account for the exact offset. */
879 hit_data += 2;
880 break;
881
882 case R_CR16_NONE:
883 return bfd_reloc_ok;
884 break;
885
886 case R_CR16_DISP4:
887 if (is_local)
888 Rvalue += -1;
889 break;
890
891 case R_CR16_DISP8:
892 case R_CR16_DISP24a:
893 if (is_local)
894 Rvalue -= -1;
895 break;
896
897 case R_CR16_SWITCH8:
898 case R_CR16_SWITCH16:
899 case R_CR16_SWITCH32:
900 /* We only care about the addend, where the difference between
901 expressions is kept. */
902 Rvalue = 0;
903
904 default:
905 break;
906 }
907
908 if (howto->pc_relative)
909 {
910 /* Subtract the address of the section containing the location. */
911 Rvalue -= (input_section->output_section->vma
912 + input_section->output_offset);
913 /* Subtract the position of the location within the section. */
914 Rvalue -= offset;
915 }
916
917 /* Add in supplied addend. */
918 Rvalue += addend;
919
920 /* Complain if the bitfield overflows, whether it is considered
921 as signed or unsigned. */
922 check = Rvalue >> howto->rightshift;
923
924 /* Assumes two's complement. This expression avoids
925 overflow if howto->bitsize is the number of bits in
926 bfd_vma. */
927 reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
928
929 /* For GOT and GOTC relocs no boundary checks applied. */
930 if (!((r_type == R_CR16_GOT_REGREL20)
931 || (r_type == R_CR16_GOTC_REGREL20)))
932 {
933 if (((bfd_vma) check & ~reloc_bits) != 0
934 && (((bfd_vma) check & ~reloc_bits)
935 != (-(bfd_vma) 1 & ~reloc_bits)))
936 {
937 /* The above right shift is incorrect for a signed
938 value. See if turning on the upper bits fixes the
939 overflow. */
940 if (howto->rightshift && (bfd_signed_vma) Rvalue < 0)
941 {
942 check |= ((bfd_vma) - 1
943 & ~((bfd_vma) - 1
944 >> howto->rightshift));
945
946 if (((bfd_vma) check & ~reloc_bits)
947 != (-(bfd_vma) 1 & ~reloc_bits))
948 return bfd_reloc_overflow;
949 }
950 else
951 return bfd_reloc_overflow;
952 }
953
954 /* Drop unwanted bits from the value we are relocating to. */
955 Rvalue >>= (bfd_vma) howto->rightshift;
956
957 /* Apply dst_mask to select only relocatable part of the insn. */
958 Rvalue &= howto->dst_mask;
959 }
960
961 switch (howto->size)
962 {
963 case 0:
964 if (r_type == R_CR16_DISP8)
965 {
966 Rvalue1 = bfd_get_16 (input_bfd, hit_data);
967 Rvalue = ((Rvalue1 & 0xf000) | ((Rvalue << 4) & 0xf00)
968 | (Rvalue1 & 0x00f0) | (Rvalue & 0xf));
969 bfd_put_16 (input_bfd, Rvalue, hit_data);
970 }
971 else if (r_type == R_CR16_IMM4)
972 {
973 Rvalue1 = bfd_get_16 (input_bfd, hit_data);
974 Rvalue = (((Rvalue1 & 0xff) << 8) | ((Rvalue << 4) & 0xf0)
975 | ((Rvalue1 & 0x0f00) >> 8));
976 bfd_put_16 (input_bfd, Rvalue, hit_data);
977 }
978 else if (r_type == R_CR16_DISP4)
979 {
980 Rvalue1 = bfd_get_16 (input_bfd, hit_data);
981 Rvalue = (Rvalue1 | ((Rvalue & 0xf) << 4));
982 bfd_put_16 (input_bfd, Rvalue, hit_data);
983 }
984 else
985 {
986 bfd_put_8 (input_bfd, (unsigned char) Rvalue, hit_data);
987 }
988 break;
989
990 case 1:
991 if (r_type == R_CR16_DISP16)
992 {
993 Rvalue |= (bfd_get_16 (input_bfd, hit_data));
994 Rvalue = ((Rvalue & 0xfffe) | ((Rvalue >> 16) & 0x1));
995 }
996 if (r_type == R_CR16_IMM16)
997 {
998 Rvalue1 = bfd_get_16 (input_bfd, hit_data);
999
1000 /* Add or subtract the offset value. */
1001 if (Rvalue1 & 0x8000)
1002 Rvalue -= (~Rvalue1 + 1) & 0xffff;
1003 else
1004 Rvalue += Rvalue1;
1005
1006 /* Check for range. */
1007 if ((long) Rvalue > 0xffff || (long) Rvalue < 0x0)
1008 return bfd_reloc_overflow;
1009 }
1010
1011 bfd_put_16 (input_bfd, Rvalue, hit_data);
1012 break;
1013
1014 case 2:
1015 if ((r_type == R_CR16_ABS20) || (r_type == R_CR16_IMM20))
1016 {
1017 Rvalue1 = (bfd_get_16 (input_bfd, hit_data + 2)
1018 | (((bfd_get_16 (input_bfd, hit_data) & 0xf) <<16)));
1019
1020 /* Add or subtract the offset value. */
1021 if (Rvalue1 & 0x80000)
1022 Rvalue -= (~Rvalue1 + 1) & 0xfffff;
1023 else
1024 Rvalue += Rvalue1;
1025
1026 /* Check for range. */
1027 if ((long) Rvalue > 0xfffff || (long) Rvalue < 0x0)
1028 return bfd_reloc_overflow;
1029
1030 bfd_put_16 (input_bfd, ((bfd_get_16 (input_bfd, hit_data) & 0xfff0)
1031 | ((Rvalue >> 16) & 0xf)), hit_data);
1032 bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
1033 }
1034 else if (r_type == R_CR16_GOT_REGREL20)
1035 {
1036 asection *sgot = elf_hash_table (info)->sgot;
1037
1038 if (h != NULL)
1039 {
1040 bfd_vma off;
1041
1042 off = h->got.offset;
1043 BFD_ASSERT (off != (bfd_vma) -1);
1044
1045 if (! elf_hash_table (info)->dynamic_sections_created
1046 || SYMBOL_REFERENCES_LOCAL (info, h))
1047 /* This is actually a static link, or it is a
1048 -Bsymbolic link and the symbol is defined
1049 locally, or the symbol was forced to be local
1050 because of a version file. We must initialize
1051 this entry in the global offset table.
1052 When doing a dynamic link, we create a .rela.got
1053 relocation entry to initialize the value. This
1054 is done in the finish_dynamic_symbol routine. */
1055 bfd_put_32 (output_bfd, Rvalue, sgot->contents + off);
1056
1057 Rvalue = sgot->output_offset + off;
1058 }
1059 else
1060 {
1061 bfd_vma off;
1062
1063 off = elf_local_got_offsets (input_bfd)[symndx];
1064 bfd_put_32 (output_bfd,Rvalue, sgot->contents + off);
1065
1066 Rvalue = sgot->output_offset + off;
1067 }
1068
1069 Rvalue += addend;
1070
1071 /* REVISIT: if ((long) Rvalue > 0xffffff ||
1072 (long) Rvalue < -0x800000). */
1073 if ((long) Rvalue > 0xffffff || (long) Rvalue < 0)
1074 return bfd_reloc_overflow;
1075
1076
1077 bfd_put_16 (input_bfd, (bfd_get_16 (input_bfd, hit_data))
1078 | (((Rvalue >> 16) & 0xf) << 8), hit_data);
1079 bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
1080
1081 }
1082 else if (r_type == R_CR16_GOTC_REGREL20)
1083 {
1084 asection *sgot = elf_hash_table (info)->sgot;
1085
1086 if (h != NULL)
1087 {
1088 bfd_vma off;
1089
1090 off = h->got.offset;
1091 BFD_ASSERT (off != (bfd_vma) -1);
1092
1093 Rvalue >>=1; /* For code symbols. */
1094
1095 if (! elf_hash_table (info)->dynamic_sections_created
1096 || SYMBOL_REFERENCES_LOCAL (info, h))
1097 /* This is actually a static link, or it is a
1098 -Bsymbolic link and the symbol is defined
1099 locally, or the symbol was forced to be local
1100 because of a version file. We must initialize
1101 this entry in the global offset table.
1102 When doing a dynamic link, we create a .rela.got
1103 relocation entry to initialize the value. This
1104 is done in the finish_dynamic_symbol routine. */
1105 bfd_put_32 (output_bfd, Rvalue, sgot->contents + off);
1106
1107 Rvalue = sgot->output_offset + off;
1108 }
1109 else
1110 {
1111 bfd_vma off;
1112
1113 off = elf_local_got_offsets (input_bfd)[symndx];
1114 Rvalue >>= 1;
1115 bfd_put_32 (output_bfd,Rvalue, sgot->contents + off);
1116 Rvalue = sgot->output_offset + off;
1117 }
1118
1119 Rvalue += addend;
1120
1121 /* Check if any value in DISP. */
1122 Rvalue1 =((bfd_get_32 (input_bfd, hit_data) >>16)
1123 | (((bfd_get_32 (input_bfd, hit_data) & 0xfff) >> 8) <<16));
1124
1125 /* Add or subtract the offset value. */
1126 if (Rvalue1 & 0x80000)
1127 Rvalue -= (~Rvalue1 + 1) & 0xfffff;
1128 else
1129 Rvalue += Rvalue1;
1130
1131 /* Check for range. */
1132 /* REVISIT: if ((long) Rvalue > 0xffffff
1133 || (long) Rvalue < -0x800000). */
1134 if ((long) Rvalue > 0xffffff || (long) Rvalue < 0)
1135 return bfd_reloc_overflow;
1136
1137 bfd_put_16 (input_bfd, (bfd_get_16 (input_bfd, hit_data))
1138 | (((Rvalue >> 16) & 0xf) << 8), hit_data);
1139 bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
1140 }
1141 else
1142 {
1143 if (r_type == R_CR16_ABS24)
1144 {
1145 Rvalue1 = ((bfd_get_32 (input_bfd, hit_data) >> 16)
1146 | (((bfd_get_32 (input_bfd, hit_data) & 0xfff) >> 8) <<16)
1147 | (((bfd_get_32 (input_bfd, hit_data) & 0xf) <<20)));
1148
1149 /* Add or subtract the offset value. */
1150 if (Rvalue1 & 0x800000)
1151 Rvalue -= (~Rvalue1 + 1) & 0xffffff;
1152 else
1153 Rvalue += Rvalue1;
1154
1155 /* Check for Range. */
1156 if ((long) Rvalue > 0xffffff || (long) Rvalue < 0x0)
1157 return bfd_reloc_overflow;
1158
1159 Rvalue = ((((Rvalue >> 20) & 0xf) | (((Rvalue >> 16) & 0xf)<<8)
1160 | (bfd_get_32 (input_bfd, hit_data) & 0xf0f0))
1161 | ((Rvalue & 0xffff) << 16));
1162 }
1163 else if (r_type == R_CR16_DISP24)
1164 {
1165 Rvalue = ((((Rvalue >> 20)& 0xf) | (((Rvalue >>16) & 0xf)<<8)
1166 | (bfd_get_16 (input_bfd, hit_data)))
1167 | (((Rvalue & 0xfffe) | ((Rvalue >> 24) & 0x1)) << 16));
1168 }
1169 else if ((r_type == R_CR16_IMM32) || (r_type == R_CR16_IMM32a))
1170 {
1171 Rvalue1 =((((bfd_get_32 (input_bfd, hit_data)) >> 16) &0xffff)
1172 | (((bfd_get_32 (input_bfd, hit_data)) &0xffff)) << 16);
1173
1174 /* Add or subtract the offset value. */
1175 if (Rvalue1 & 0x80000000)
1176 Rvalue -= (~Rvalue1 + 1) & 0xffffffff;
1177 else
1178 Rvalue += Rvalue1;
1179
1180 /* Check for range. */
1181 if (Rvalue > 0xffffffff || (long) Rvalue < 0x0)
1182 return bfd_reloc_overflow;
1183
1184 Rvalue = (((Rvalue >> 16)& 0xffff) | (Rvalue & 0xffff) << 16);
1185 }
1186 else if (r_type == R_CR16_DISP24a)
1187 {
1188 Rvalue = (((Rvalue & 0xfffffe) | (Rvalue >> 23)));
1189 Rvalue = ((Rvalue >> 16) & 0xff) | ((Rvalue & 0xffff) << 16)
1190 | (bfd_get_32 (input_bfd, hit_data));
1191 }
1192 else if ((r_type == R_CR16_REGREL20)
1193 || (r_type == R_CR16_REGREL20a))
1194 {
1195 Rvalue1 = ((bfd_get_32 (input_bfd, hit_data) >> 16)
1196 | (((bfd_get_32 (input_bfd, hit_data) & 0xfff) >> 8) <<16));
1197 /* Add or subtract the offset value. */
1198 if (Rvalue1 & 0x80000)
1199 Rvalue -= (~Rvalue1 + 1) & 0xfffff;
1200 else
1201 Rvalue += Rvalue1;
1202
1203 /* Check for range. */
1204 if ((long) Rvalue > 0xfffff || (long) Rvalue < 0x0)
1205 return bfd_reloc_overflow;
1206
1207 Rvalue = (((((Rvalue >> 20)& 0xf) | (((Rvalue >>16) & 0xf)<<8)
1208 | ((Rvalue & 0xffff) << 16)))
1209 | (bfd_get_32 (input_bfd, hit_data) & 0xf0ff));
1210
1211 }
1212 else if (r_type == R_CR16_NUM32)
1213 {
1214 Rvalue1 = (bfd_get_32 (input_bfd, hit_data));
1215
1216 /* Add or subtract the offset value */
1217 if (Rvalue1 & 0x80000000)
1218 Rvalue -= (~Rvalue1 + 1) & 0xffffffff;
1219 else
1220 Rvalue += Rvalue1;
1221
1222 /* Check for Ranga */
1223 if (Rvalue > 0xffffffff)
1224 return bfd_reloc_overflow;
1225 }
1226
1227 bfd_put_32 (input_bfd, Rvalue, hit_data);
1228 }
1229 break;
1230
1231 default:
1232 return bfd_reloc_notsupported;
1233 }
1234
1235 return bfd_reloc_ok;
1236 }
1237
1238 /* Delete some bytes from a section while relaxing. */
1239
1240 static bfd_boolean
1241 elf32_cr16_relax_delete_bytes (struct bfd_link_info *link_info, bfd *abfd,
1242 asection *sec, bfd_vma addr, int count)
1243 {
1244 Elf_Internal_Shdr *symtab_hdr;
1245 unsigned int sec_shndx;
1246 bfd_byte *contents;
1247 Elf_Internal_Rela *irel, *irelend;
1248 bfd_vma toaddr;
1249 Elf_Internal_Sym *isym;
1250 Elf_Internal_Sym *isymend;
1251 struct elf_link_hash_entry **sym_hashes;
1252 struct elf_link_hash_entry **end_hashes;
1253 struct elf_link_hash_entry **start_hashes;
1254 unsigned int symcount;
1255
1256 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1257
1258 contents = elf_section_data (sec)->this_hdr.contents;
1259
1260 toaddr = sec->size;
1261
1262 irel = elf_section_data (sec)->relocs;
1263 irelend = irel + sec->reloc_count;
1264
1265 /* Actually delete the bytes. */
1266 memmove (contents + addr, contents + addr + count,
1267 (size_t) (toaddr - addr - count));
1268 sec->size -= count;
1269
1270 /* Adjust all the relocs. */
1271 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1272 /* Get the new reloc address. */
1273 if ((irel->r_offset > addr && irel->r_offset < toaddr))
1274 irel->r_offset -= count;
1275
1276 /* Adjust the local symbols defined in this section. */
1277 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1278 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1279 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1280 {
1281 if (isym->st_shndx == sec_shndx
1282 && isym->st_value > addr
1283 && isym->st_value < toaddr)
1284 {
1285 /* Adjust the addend of SWITCH relocations in this section,
1286 which reference this local symbol. */
1287 #if 0
1288 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1289 {
1290 unsigned long r_symndx;
1291 Elf_Internal_Sym *rsym;
1292 bfd_vma addsym, subsym;
1293
1294 /* Skip if not a SWITCH relocation. */
1295 if (ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH8
1296 && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH16
1297 && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH32)
1298 continue;
1299
1300 r_symndx = ELF32_R_SYM (irel->r_info);
1301 rsym = (Elf_Internal_Sym *) symtab_hdr->contents + r_symndx;
1302
1303 /* Skip if not the local adjusted symbol. */
1304 if (rsym != isym)
1305 continue;
1306
1307 addsym = isym->st_value;
1308 subsym = addsym - irel->r_addend;
1309
1310 /* Fix the addend only when -->> (addsym > addr >= subsym). */
1311 if (subsym <= addr)
1312 irel->r_addend -= count;
1313 else
1314 continue;
1315 }
1316 #endif
1317
1318 isym->st_value -= count;
1319 }
1320 }
1321
1322 /* Now adjust the global symbols defined in this section. */
1323 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1324 - symtab_hdr->sh_info);
1325 sym_hashes = start_hashes = elf_sym_hashes (abfd);
1326 end_hashes = sym_hashes + symcount;
1327
1328 for (; sym_hashes < end_hashes; sym_hashes++)
1329 {
1330 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1331
1332 /* The '--wrap SYMBOL' option is causing a pain when the object file,
1333 containing the definition of __wrap_SYMBOL, includes a direct
1334 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
1335 the same symbol (which is __wrap_SYMBOL), but still exist as two
1336 different symbols in 'sym_hashes', we don't want to adjust
1337 the global symbol __wrap_SYMBOL twice.
1338 This check is only relevant when symbols are being wrapped. */
1339 if (link_info->wrap_hash != NULL)
1340 {
1341 struct elf_link_hash_entry **cur_sym_hashes;
1342
1343 /* Loop only over the symbols whom been already checked. */
1344 for (cur_sym_hashes = start_hashes; cur_sym_hashes < sym_hashes;
1345 cur_sym_hashes++)
1346 /* If the current symbol is identical to 'sym_hash', that means
1347 the symbol was already adjusted (or at least checked). */
1348 if (*cur_sym_hashes == sym_hash)
1349 break;
1350
1351 /* Don't adjust the symbol again. */
1352 if (cur_sym_hashes < sym_hashes)
1353 continue;
1354 }
1355
1356 if ((sym_hash->root.type == bfd_link_hash_defined
1357 || sym_hash->root.type == bfd_link_hash_defweak)
1358 && sym_hash->root.u.def.section == sec
1359 && sym_hash->root.u.def.value > addr
1360 && sym_hash->root.u.def.value < toaddr)
1361 sym_hash->root.u.def.value -= count;
1362 }
1363
1364 return TRUE;
1365 }
1366
1367 /* Relocate a CR16 ELF section. */
1368
1369 static bfd_boolean
1370 elf32_cr16_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
1371 bfd *input_bfd, asection *input_section,
1372 bfd_byte *contents, Elf_Internal_Rela *relocs,
1373 Elf_Internal_Sym *local_syms,
1374 asection **local_sections)
1375 {
1376 Elf_Internal_Shdr *symtab_hdr;
1377 struct elf_link_hash_entry **sym_hashes;
1378 Elf_Internal_Rela *rel, *relend;
1379
1380 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1381 sym_hashes = elf_sym_hashes (input_bfd);
1382
1383 rel = relocs;
1384 relend = relocs + input_section->reloc_count;
1385 for (; rel < relend; rel++)
1386 {
1387 int r_type;
1388 reloc_howto_type *howto;
1389 unsigned long r_symndx;
1390 Elf_Internal_Sym *sym;
1391 asection *sec;
1392 struct elf_link_hash_entry *h;
1393 bfd_vma relocation;
1394 bfd_reloc_status_type r;
1395
1396 r_symndx = ELF32_R_SYM (rel->r_info);
1397 r_type = ELF32_R_TYPE (rel->r_info);
1398 howto = cr16_elf_howto_table + (r_type);
1399
1400 h = NULL;
1401 sym = NULL;
1402 sec = NULL;
1403 if (r_symndx < symtab_hdr->sh_info)
1404 {
1405 sym = local_syms + r_symndx;
1406 sec = local_sections[r_symndx];
1407 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1408 }
1409 else
1410 {
1411 bfd_boolean unresolved_reloc, warned, ignored;
1412
1413 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1414 r_symndx, symtab_hdr, sym_hashes,
1415 h, sec, relocation,
1416 unresolved_reloc, warned, ignored);
1417 }
1418
1419 if (sec != NULL && discarded_section (sec))
1420 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1421 rel, 1, relend, howto, 0, contents);
1422
1423 if (bfd_link_relocatable (info))
1424 continue;
1425
1426 r = cr16_elf_final_link_relocate (howto, input_bfd, output_bfd,
1427 input_section,
1428 contents, rel->r_offset,
1429 relocation, rel->r_addend,
1430 (struct elf_link_hash_entry *) h,
1431 r_symndx,
1432 info, sec, h == NULL);
1433
1434 if (r != bfd_reloc_ok)
1435 {
1436 const char *name;
1437 const char *msg = NULL;
1438
1439 if (h != NULL)
1440 name = h->root.root.string;
1441 else
1442 {
1443 name = (bfd_elf_string_from_elf_section
1444 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1445 if (name == NULL || *name == '\0')
1446 name = bfd_section_name (input_bfd, sec);
1447 }
1448
1449 switch (r)
1450 {
1451 case bfd_reloc_overflow:
1452 (*info->callbacks->reloc_overflow)
1453 (info, (h ? &h->root : NULL), name, howto->name,
1454 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1455 break;
1456
1457 case bfd_reloc_undefined:
1458 (*info->callbacks->undefined_symbol)
1459 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1460 break;
1461
1462 case bfd_reloc_outofrange:
1463 msg = _("internal error: out of range error");
1464 goto common_error;
1465
1466 case bfd_reloc_notsupported:
1467 msg = _("internal error: unsupported relocation error");
1468 goto common_error;
1469
1470 case bfd_reloc_dangerous:
1471 msg = _("internal error: dangerous error");
1472 goto common_error;
1473
1474 default:
1475 msg = _("internal error: unknown error");
1476 /* Fall through. */
1477
1478 common_error:
1479 (*info->callbacks->warning) (info, msg, name, input_bfd,
1480 input_section, rel->r_offset);
1481 break;
1482 }
1483 }
1484 }
1485
1486 return TRUE;
1487 }
1488
1489 /* This is a version of bfd_generic_get_relocated_section_contents
1490 which uses elf32_cr16_relocate_section. */
1491
1492 static bfd_byte *
1493 elf32_cr16_get_relocated_section_contents (bfd *output_bfd,
1494 struct bfd_link_info *link_info,
1495 struct bfd_link_order *link_order,
1496 bfd_byte *data,
1497 bfd_boolean relocatable,
1498 asymbol **symbols)
1499 {
1500 Elf_Internal_Shdr *symtab_hdr;
1501 asection *input_section = link_order->u.indirect.section;
1502 bfd *input_bfd = input_section->owner;
1503 asection **sections = NULL;
1504 Elf_Internal_Rela *internal_relocs = NULL;
1505 Elf_Internal_Sym *isymbuf = NULL;
1506
1507 /* We only need to handle the case of relaxing, or of having a
1508 particular set of section contents, specially. */
1509 if (relocatable
1510 || elf_section_data (input_section)->this_hdr.contents == NULL)
1511 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1512 link_order, data,
1513 relocatable,
1514 symbols);
1515
1516 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1517
1518 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1519 (size_t) input_section->size);
1520
1521 if ((input_section->flags & SEC_RELOC) != 0
1522 && input_section->reloc_count > 0)
1523 {
1524 Elf_Internal_Sym *isym;
1525 Elf_Internal_Sym *isymend;
1526 asection **secpp;
1527 bfd_size_type amt;
1528
1529 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
1530 NULL, NULL, FALSE);
1531 if (internal_relocs == NULL)
1532 goto error_return;
1533
1534 if (symtab_hdr->sh_info != 0)
1535 {
1536 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1537 if (isymbuf == NULL)
1538 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1539 symtab_hdr->sh_info, 0,
1540 NULL, NULL, NULL);
1541 if (isymbuf == NULL)
1542 goto error_return;
1543 }
1544
1545 amt = symtab_hdr->sh_info;
1546 amt *= sizeof (asection *);
1547 sections = bfd_malloc (amt);
1548 if (sections == NULL && amt != 0)
1549 goto error_return;
1550
1551 isymend = isymbuf + symtab_hdr->sh_info;
1552 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1553 {
1554 asection *isec;
1555
1556 if (isym->st_shndx == SHN_UNDEF)
1557 isec = bfd_und_section_ptr;
1558 else if (isym->st_shndx == SHN_ABS)
1559 isec = bfd_abs_section_ptr;
1560 else if (isym->st_shndx == SHN_COMMON)
1561 isec = bfd_com_section_ptr;
1562 else
1563 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1564
1565 *secpp = isec;
1566 }
1567
1568 if (! elf32_cr16_relocate_section (output_bfd, link_info, input_bfd,
1569 input_section, data, internal_relocs,
1570 isymbuf, sections))
1571 goto error_return;
1572
1573 if (sections != NULL)
1574 free (sections);
1575 if (isymbuf != NULL
1576 && symtab_hdr->contents != (unsigned char *) isymbuf)
1577 free (isymbuf);
1578 if (elf_section_data (input_section)->relocs != internal_relocs)
1579 free (internal_relocs);
1580 }
1581
1582 return data;
1583
1584 error_return:
1585 if (sections != NULL)
1586 free (sections);
1587 if (isymbuf != NULL
1588 && symtab_hdr->contents != (unsigned char *) isymbuf)
1589 free (isymbuf);
1590 if (internal_relocs != NULL
1591 && elf_section_data (input_section)->relocs != internal_relocs)
1592 free (internal_relocs);
1593 return NULL;
1594 }
1595
1596 /* Assorted hash table functions. */
1597
1598 /* Initialize an entry in the link hash table. */
1599
1600 /* Create an entry in an CR16 ELF linker hash table. */
1601
1602 static struct bfd_hash_entry *
1603 elf32_cr16_link_hash_newfunc (struct bfd_hash_entry *entry,
1604 struct bfd_hash_table *table,
1605 const char *string)
1606 {
1607 struct elf32_cr16_link_hash_entry *ret =
1608 (struct elf32_cr16_link_hash_entry *) entry;
1609
1610 /* Allocate the structure if it has not already been allocated by a
1611 subclass. */
1612 if (ret == (struct elf32_cr16_link_hash_entry *) NULL)
1613 ret = ((struct elf32_cr16_link_hash_entry *)
1614 bfd_hash_allocate (table,
1615 sizeof (struct elf32_cr16_link_hash_entry)));
1616 if (ret == (struct elf32_cr16_link_hash_entry *) NULL)
1617 return (struct bfd_hash_entry *) ret;
1618
1619 /* Call the allocation method of the superclass. */
1620 ret = ((struct elf32_cr16_link_hash_entry *)
1621 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1622 table, string));
1623 if (ret != (struct elf32_cr16_link_hash_entry *) NULL)
1624 {
1625 ret->direct_calls = 0;
1626 ret->stack_size = 0;
1627 ret->movm_args = 0;
1628 ret->movm_stack_size = 0;
1629 ret->flags = 0;
1630 ret->value = 0;
1631 }
1632
1633 return (struct bfd_hash_entry *) ret;
1634 }
1635
1636 /* Create an cr16 ELF linker hash table. */
1637
1638 static struct bfd_link_hash_table *
1639 elf32_cr16_link_hash_table_create (bfd *abfd)
1640 {
1641 struct elf_link_hash_table *ret;
1642 bfd_size_type amt = sizeof (struct elf_link_hash_table);
1643
1644 ret = (struct elf_link_hash_table *) bfd_zmalloc (amt);
1645 if (ret == (struct elf_link_hash_table *) NULL)
1646 return NULL;
1647
1648 if (!_bfd_elf_link_hash_table_init (ret, abfd,
1649 elf32_cr16_link_hash_newfunc,
1650 sizeof (struct elf32_cr16_link_hash_entry),
1651 GENERIC_ELF_DATA))
1652 {
1653 free (ret);
1654 return NULL;
1655 }
1656
1657 return &ret->root;
1658 }
1659
1660 static unsigned long
1661 elf_cr16_mach (flagword flags)
1662 {
1663 switch (flags)
1664 {
1665 case EM_CR16:
1666 default:
1667 return bfd_mach_cr16;
1668 }
1669 }
1670
1671 /* The final processing done just before writing out a CR16 ELF object
1672 file. This gets the CR16 architecture right based on the machine
1673 number. */
1674
1675 static void
1676 _bfd_cr16_elf_final_write_processing (bfd *abfd,
1677 bfd_boolean linker ATTRIBUTE_UNUSED)
1678 {
1679 unsigned long val;
1680 switch (bfd_get_mach (abfd))
1681 {
1682 default:
1683 case bfd_mach_cr16:
1684 val = EM_CR16;
1685 break;
1686 }
1687
1688
1689 elf_elfheader (abfd)->e_flags |= val;
1690 }
1691
1692
1693 static bfd_boolean
1694 _bfd_cr16_elf_object_p (bfd *abfd)
1695 {
1696 bfd_default_set_arch_mach (abfd, bfd_arch_cr16,
1697 elf_cr16_mach (elf_elfheader (abfd)->e_flags));
1698 return TRUE;
1699 }
1700
1701 /* Merge backend specific data from an object file to the output
1702 object file when linking. */
1703
1704 static bfd_boolean
1705 _bfd_cr16_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
1706 {
1707 bfd *obfd = info->output_bfd;
1708
1709 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1710 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1711 return TRUE;
1712
1713 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1714 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
1715 {
1716 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
1717 bfd_get_mach (ibfd)))
1718 return FALSE;
1719 }
1720
1721 return TRUE;
1722 }
1723
1724
1725 /* This function handles relaxing for the CR16.
1726
1727 There's quite a few relaxing opportunites available on the CR16:
1728
1729 * bcond:24 -> bcond:16 1 byte
1730 * bcond:16 -> bcond:8 1 byte
1731 * arithmetic imm32 -> arithmetic imm20 12 bits
1732 * arithmetic imm20/imm16 -> arithmetic imm4 12/16 bits
1733
1734 Symbol- and reloc-reading infrastructure copied from elf-m10200.c. */
1735
1736 static bfd_boolean
1737 elf32_cr16_relax_section (bfd *abfd, asection *sec,
1738 struct bfd_link_info *link_info, bfd_boolean *again)
1739 {
1740 Elf_Internal_Shdr *symtab_hdr;
1741 Elf_Internal_Rela *internal_relocs;
1742 Elf_Internal_Rela *irel, *irelend;
1743 bfd_byte *contents = NULL;
1744 Elf_Internal_Sym *isymbuf = NULL;
1745
1746 /* Assume nothing changes. */
1747 *again = FALSE;
1748
1749 /* We don't have to do anything for a relocatable link, if
1750 this section does not have relocs, or if this is not a
1751 code section. */
1752 if (bfd_link_relocatable (link_info)
1753 || (sec->flags & SEC_RELOC) == 0
1754 || sec->reloc_count == 0
1755 || (sec->flags & SEC_CODE) == 0)
1756 return TRUE;
1757
1758 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1759
1760 /* Get a copy of the native relocations. */
1761 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
1762 link_info->keep_memory);
1763 if (internal_relocs == NULL)
1764 goto error_return;
1765
1766 /* Walk through them looking for relaxing opportunities. */
1767 irelend = internal_relocs + sec->reloc_count;
1768 for (irel = internal_relocs; irel < irelend; irel++)
1769 {
1770 bfd_vma symval;
1771
1772 /* If this isn't something that can be relaxed, then ignore
1773 this reloc. */
1774 if (ELF32_R_TYPE (irel->r_info) != (int) R_CR16_DISP16
1775 && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_DISP24
1776 && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_IMM32
1777 && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_IMM20
1778 && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_IMM16)
1779 continue;
1780
1781 /* Get the section contents if we haven't done so already. */
1782 if (contents == NULL)
1783 {
1784 /* Get cached copy if it exists. */
1785 if (elf_section_data (sec)->this_hdr.contents != NULL)
1786 contents = elf_section_data (sec)->this_hdr.contents;
1787 /* Go get them off disk. */
1788 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1789 goto error_return;
1790 }
1791
1792 /* Read this BFD's local symbols if we haven't done so already. */
1793 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1794 {
1795 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1796 if (isymbuf == NULL)
1797 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1798 symtab_hdr->sh_info, 0,
1799 NULL, NULL, NULL);
1800 if (isymbuf == NULL)
1801 goto error_return;
1802 }
1803
1804 /* Get the value of the symbol referred to by the reloc. */
1805 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1806 {
1807 /* A local symbol. */
1808 Elf_Internal_Sym *isym;
1809 asection *sym_sec;
1810
1811 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1812 if (isym->st_shndx == SHN_UNDEF)
1813 sym_sec = bfd_und_section_ptr;
1814 else if (isym->st_shndx == SHN_ABS)
1815 sym_sec = bfd_abs_section_ptr;
1816 else if (isym->st_shndx == SHN_COMMON)
1817 sym_sec = bfd_com_section_ptr;
1818 else
1819 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1820 symval = (isym->st_value
1821 + sym_sec->output_section->vma
1822 + sym_sec->output_offset);
1823 }
1824 else
1825 {
1826 unsigned long indx;
1827 struct elf_link_hash_entry *h;
1828
1829 /* An external symbol. */
1830 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1831 h = elf_sym_hashes (abfd)[indx];
1832 BFD_ASSERT (h != NULL);
1833
1834 if (h->root.type != bfd_link_hash_defined
1835 && h->root.type != bfd_link_hash_defweak)
1836 /* This appears to be a reference to an undefined
1837 symbol. Just ignore it--it will be caught by the
1838 regular reloc processing. */
1839 continue;
1840
1841 symval = (h->root.u.def.value
1842 + h->root.u.def.section->output_section->vma
1843 + h->root.u.def.section->output_offset);
1844 }
1845
1846 /* For simplicity of coding, we are going to modify the section
1847 contents, the section relocs, and the BFD symbol table. We
1848 must tell the rest of the code not to free up this
1849 information. It would be possible to instead create a table
1850 of changes which have to be made, as is done in coff-mips.c;
1851 that would be more work, but would require less memory when
1852 the linker is run. */
1853
1854 /* Try to turn a 24 branch/call into a 16bit relative
1855 branch/call. */
1856 if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_DISP24)
1857 {
1858 bfd_vma value = symval;
1859
1860 /* Deal with pc-relative gunk. */
1861 value -= (sec->output_section->vma + sec->output_offset);
1862 value -= irel->r_offset;
1863 value += irel->r_addend;
1864
1865 /* See if the value will fit in 16 bits, note the high value is
1866 0xfffe + 2 as the target will be two bytes closer if we are
1867 able to relax. */
1868 if ((long) value < 0x10000 && (long) value > -0x10002)
1869 {
1870 unsigned int code;
1871
1872 /* Get the opcode. */
1873 code = (unsigned int) bfd_get_32 (abfd, contents + irel->r_offset);
1874
1875 /* Verify it's a 'bcond' and fix the opcode. */
1876 if ((code & 0xffff) == 0x0010)
1877 bfd_put_16 (abfd, 0x1800 | ((0xf & (code >> 20)) << 4), contents + irel->r_offset);
1878 else
1879 continue;
1880
1881 /* Note that we've changed the relocs, section contents, etc. */
1882 elf_section_data (sec)->relocs = internal_relocs;
1883 elf_section_data (sec)->this_hdr.contents = contents;
1884 symtab_hdr->contents = (unsigned char *) isymbuf;
1885
1886 /* Fix the relocation's type. */
1887 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1888 R_CR16_DISP16);
1889
1890 /* Delete two bytes of data. */
1891 if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
1892 irel->r_offset + 2, 2))
1893 goto error_return;
1894
1895 /* That will change things, so, we should relax again.
1896 Note that this is not required, and it may be slow. */
1897 *again = TRUE;
1898 }
1899 }
1900
1901 /* Try to turn a 16bit pc-relative branch into an
1902 8bit pc-relative branch. */
1903 if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_DISP16)
1904 {
1905 bfd_vma value = symval;
1906
1907 /* Deal with pc-relative gunk. */
1908 value -= (sec->output_section->vma + sec->output_offset);
1909 value -= irel->r_offset;
1910 value += irel->r_addend;
1911
1912 /* See if the value will fit in 8 bits, note the high value is
1913 0xfc + 2 as the target will be two bytes closer if we are
1914 able to relax. */
1915 /*if ((long) value < 0x1fa && (long) value > -0x100) REVISIT:range */
1916 if ((long) value < 0xfa && (long) value > -0x100)
1917 {
1918 unsigned short code;
1919
1920 /* Get the opcode. */
1921 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1922
1923 /* Verify it's a 'bcond' and fix the opcode. */
1924 if ((code & 0xff0f) == 0x1800)
1925 bfd_put_16 (abfd, (code & 0xf0f0), contents + irel->r_offset);
1926 else
1927 continue;
1928
1929 /* Note that we've changed the relocs, section contents, etc. */
1930 elf_section_data (sec)->relocs = internal_relocs;
1931 elf_section_data (sec)->this_hdr.contents = contents;
1932 symtab_hdr->contents = (unsigned char *) isymbuf;
1933
1934 /* Fix the relocation's type. */
1935 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1936 R_CR16_DISP8);
1937
1938 /* Delete two bytes of data. */
1939 if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
1940 irel->r_offset + 2, 2))
1941 goto error_return;
1942
1943 /* That will change things, so, we should relax again.
1944 Note that this is not required, and it may be slow. */
1945 *again = TRUE;
1946 }
1947 }
1948
1949 /* Try to turn a 32-bit IMM address into a 20/16-bit IMM address */
1950 if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM32)
1951 {
1952 bfd_vma value = symval;
1953 unsigned short is_add_mov = 0;
1954 bfd_vma value1 = 0;
1955
1956 /* Get the existing value from the mcode */
1957 value1 = ((bfd_get_32 (abfd, contents + irel->r_offset + 2) >> 16)
1958 |(((bfd_get_32 (abfd, contents + irel->r_offset + 2) & 0xffff) << 16)));
1959
1960 /* See if the value will fit in 20 bits. */
1961 if ((long) (value + value1) < 0xfffff && (long) (value + value1) > 0)
1962 {
1963 unsigned short code;
1964
1965 /* Get the opcode. */
1966 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1967
1968 /* Verify it's a 'arithmetic ADDD or MOVD instruction'.
1969 For ADDD and MOVD only, convert to IMM32 -> IMM20. */
1970
1971 if (((code & 0xfff0) == 0x0070) || ((code & 0xfff0) == 0x0020))
1972 is_add_mov = 1;
1973
1974 if (is_add_mov)
1975 {
1976 /* Note that we've changed the relocs, section contents,
1977 etc. */
1978 elf_section_data (sec)->relocs = internal_relocs;
1979 elf_section_data (sec)->this_hdr.contents = contents;
1980 symtab_hdr->contents = (unsigned char *) isymbuf;
1981
1982 /* Fix the opcode. */
1983 if ((code & 0xfff0) == 0x0070) /* For movd. */
1984 bfd_put_8 (abfd, 0x05, contents + irel->r_offset + 1);
1985 else /* code == 0x0020 for addd. */
1986 bfd_put_8 (abfd, 0x04, contents + irel->r_offset + 1);
1987
1988 bfd_put_8 (abfd, (code & 0xf) << 4, contents + irel->r_offset);
1989
1990 /* If existing value is nagavive adjust approriately
1991 place the 16-20bits (ie 4 bit) in new opcode,
1992 as the 0xffffxxxx, the higher 2 byte values removed. */
1993 if (value1 & 0x80000000)
1994 bfd_put_8 (abfd, (0x0f | (bfd_get_8(abfd, contents + irel->r_offset))), contents + irel->r_offset);
1995 else
1996 bfd_put_8 (abfd, (((value1 >> 16)&0xf) | (bfd_get_8(abfd, contents + irel->r_offset))), contents + irel->r_offset);
1997
1998 /* Fix the relocation's type. */
1999 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2000 R_CR16_IMM20);
2001
2002 /* Delete two bytes of data. */
2003 if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
2004 irel->r_offset + 2, 2))
2005 goto error_return;
2006
2007 /* That will change things, so, we should relax again.
2008 Note that this is not required, and it may be slow. */
2009 *again = TRUE;
2010 }
2011 }
2012
2013 /* See if the value will fit in 16 bits. */
2014 if ((!is_add_mov)
2015 && ((long)(value + value1) < 0x7fff && (long)(value + value1) > 0))
2016 {
2017 unsigned short code;
2018
2019 /* Get the opcode. */
2020 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
2021
2022 /* Note that we've changed the relocs, section contents, etc. */
2023 elf_section_data (sec)->relocs = internal_relocs;
2024 elf_section_data (sec)->this_hdr.contents = contents;
2025 symtab_hdr->contents = (unsigned char *) isymbuf;
2026
2027 /* Fix the opcode. */
2028 if ((code & 0xf0) == 0x70) /* For movd. */
2029 bfd_put_8 (abfd, 0x54, contents + irel->r_offset + 1);
2030 else if ((code & 0xf0) == 0x20) /* For addd. */
2031 bfd_put_8 (abfd, 0x60, contents + irel->r_offset + 1);
2032 else if ((code & 0xf0) == 0x90) /* For cmpd. */
2033 bfd_put_8 (abfd, 0x56, contents + irel->r_offset + 1);
2034 else
2035 continue;
2036
2037 bfd_put_8 (abfd, 0xb0 | (code & 0xf), contents + irel->r_offset);
2038
2039 /* If existing value is nagavive adjust approriately
2040 place the 12-16bits (ie 4 bit) in new opcode,
2041 as the 0xfffffxxx, the higher 2 byte values removed. */
2042 if (value1 & 0x80000000)
2043 bfd_put_8 (abfd, (0x0f | (bfd_get_8(abfd, contents + irel->r_offset))), contents + irel->r_offset);
2044 else
2045 bfd_put_16 (abfd, value1, contents + irel->r_offset + 2);
2046
2047
2048 /* Fix the relocation's type. */
2049 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2050 R_CR16_IMM16);
2051
2052 /* Delete two bytes of data. */
2053 if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
2054 irel->r_offset + 2, 2))
2055 goto error_return;
2056
2057 /* That will change things, so, we should relax again.
2058 Note that this is not required, and it may be slow. */
2059 *again = TRUE;
2060 }
2061 }
2062
2063 #if 0
2064 /* Try to turn a 16bit immediate address into a 4bit
2065 immediate address. */
2066 if ((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM20)
2067 || (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM16))
2068 {
2069 bfd_vma value = symval;
2070 bfd_vma value1 = 0;
2071
2072 /* Get the existing value from the mcode */
2073 value1 = ((bfd_get_16 (abfd, contents + irel->r_offset + 2) & 0xffff));
2074
2075 if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM20)
2076 {
2077 value1 |= ((bfd_get_16 (abfd, contents + irel->r_offset + 1) & 0xf000) << 0x4);
2078 }
2079
2080 /* See if the value will fit in 4 bits. */
2081 if ((((long) (value + value1)) < 0xf)
2082 && (((long) (value + value1)) > 0))
2083 {
2084 unsigned short code;
2085
2086 /* Get the opcode. */
2087 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
2088
2089 /* Note that we've changed the relocs, section contents, etc. */
2090 elf_section_data (sec)->relocs = internal_relocs;
2091 elf_section_data (sec)->this_hdr.contents = contents;
2092 symtab_hdr->contents = (unsigned char *) isymbuf;
2093
2094 /* Fix the opcode. */
2095 if (((code & 0x0f00) == 0x0400) || ((code & 0x0f00) == 0x0500))
2096 {
2097 if ((code & 0x0f00) == 0x0400) /* For movd imm20. */
2098 bfd_put_8 (abfd, 0x60, contents + irel->r_offset);
2099 else /* For addd imm20. */
2100 bfd_put_8 (abfd, 0x54, contents + irel->r_offset);
2101 bfd_put_8 (abfd, (code & 0xf0) >> 4, contents + irel->r_offset + 1);
2102 }
2103 else
2104 {
2105 if ((code & 0xfff0) == 0x56b0) /* For cmpd imm16. */
2106 bfd_put_8 (abfd, 0x56, contents + irel->r_offset);
2107 else if ((code & 0xfff0) == 0x54b0) /* For movd imm16. */
2108 bfd_put_8 (abfd, 0x54, contents + irel->r_offset);
2109 else if ((code & 0xfff0) == 0x58b0) /* For movb imm16. */
2110 bfd_put_8 (abfd, 0x58, contents + irel->r_offset);
2111 else if ((code & 0xfff0) == 0x5Ab0) /* For movw imm16. */
2112 bfd_put_8 (abfd, 0x5A, contents + irel->r_offset);
2113 else if ((code & 0xfff0) == 0x60b0) /* For addd imm16. */
2114 bfd_put_8 (abfd, 0x60, contents + irel->r_offset);
2115 else if ((code & 0xfff0) == 0x30b0) /* For addb imm16. */
2116 bfd_put_8 (abfd, 0x30, contents + irel->r_offset);
2117 else if ((code & 0xfff0) == 0x2Cb0) /* For addub imm16. */
2118 bfd_put_8 (abfd, 0x2C, contents + irel->r_offset);
2119 else if ((code & 0xfff0) == 0x32b0) /* For adduw imm16. */
2120 bfd_put_8 (abfd, 0x32, contents + irel->r_offset);
2121 else if ((code & 0xfff0) == 0x38b0) /* For subb imm16. */
2122 bfd_put_8 (abfd, 0x38, contents + irel->r_offset);
2123 else if ((code & 0xfff0) == 0x3Cb0) /* For subcb imm16. */
2124 bfd_put_8 (abfd, 0x3C, contents + irel->r_offset);
2125 else if ((code & 0xfff0) == 0x3Fb0) /* For subcw imm16. */
2126 bfd_put_8 (abfd, 0x3F, contents + irel->r_offset);
2127 else if ((code & 0xfff0) == 0x3Ab0) /* For subw imm16. */
2128 bfd_put_8 (abfd, 0x3A, contents + irel->r_offset);
2129 else if ((code & 0xfff0) == 0x50b0) /* For cmpb imm16. */
2130 bfd_put_8 (abfd, 0x50, contents + irel->r_offset);
2131 else if ((code & 0xfff0) == 0x52b0) /* For cmpw imm16. */
2132 bfd_put_8 (abfd, 0x52, contents + irel->r_offset);
2133 else
2134 continue;
2135
2136 bfd_put_8 (abfd, (code & 0xf), contents + irel->r_offset + 1);
2137 }
2138
2139 /* Fix the relocation's type. */
2140 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2141 R_CR16_IMM4);
2142
2143 /* Delete two bytes of data. */
2144 if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
2145 irel->r_offset + 2, 2))
2146 goto error_return;
2147
2148 /* That will change things, so, we should relax again.
2149 Note that this is not required, and it may be slow. */
2150 *again = TRUE;
2151 }
2152 }
2153 #endif
2154 }
2155
2156 if (isymbuf != NULL
2157 && symtab_hdr->contents != (unsigned char *) isymbuf)
2158 {
2159 if (! link_info->keep_memory)
2160 free (isymbuf);
2161 else
2162 /* Cache the symbols for elf_link_input_bfd. */
2163 symtab_hdr->contents = (unsigned char *) isymbuf;
2164 }
2165
2166 if (contents != NULL
2167 && elf_section_data (sec)->this_hdr.contents != contents)
2168 {
2169 if (! link_info->keep_memory)
2170 free (contents);
2171 else
2172 /* Cache the section contents for elf_link_input_bfd. */
2173 elf_section_data (sec)->this_hdr.contents = contents;
2174
2175 }
2176
2177 if (internal_relocs != NULL
2178 && elf_section_data (sec)->relocs != internal_relocs)
2179 free (internal_relocs);
2180
2181 return TRUE;
2182
2183 error_return:
2184 if (isymbuf != NULL
2185 && symtab_hdr->contents != (unsigned char *) isymbuf)
2186 free (isymbuf);
2187 if (contents != NULL
2188 && elf_section_data (sec)->this_hdr.contents != contents)
2189 free (contents);
2190 if (internal_relocs != NULL
2191 && elf_section_data (sec)->relocs != internal_relocs)
2192 free (internal_relocs);
2193
2194 return FALSE;
2195 }
2196
2197 static asection *
2198 elf32_cr16_gc_mark_hook (asection *sec,
2199 struct bfd_link_info *info,
2200 Elf_Internal_Rela *rel,
2201 struct elf_link_hash_entry *h,
2202 Elf_Internal_Sym *sym)
2203 {
2204 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2205 }
2206
2207 /* Create dynamic sections when linking against a dynamic object. */
2208
2209 static bfd_boolean
2210 _bfd_cr16_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2211 {
2212 flagword flags;
2213 asection * s;
2214 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
2215 struct elf_link_hash_table *htab = elf_hash_table (info);
2216 int ptralign = 0;
2217
2218 switch (bed->s->arch_size)
2219 {
2220 case 16:
2221 ptralign = 1;
2222 break;
2223
2224 case 32:
2225 ptralign = 2;
2226 break;
2227
2228 default:
2229 bfd_set_error (bfd_error_bad_value);
2230 return FALSE;
2231 }
2232
2233 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2234 .rel[a].bss sections. */
2235
2236 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2237 | SEC_LINKER_CREATED);
2238
2239 s = bfd_make_section_anyway_with_flags (abfd,
2240 (bed->default_use_rela_p
2241 ? ".rela.plt" : ".rel.plt"),
2242 flags | SEC_READONLY);
2243 htab->srelplt = s;
2244 if (s == NULL
2245 || ! bfd_set_section_alignment (abfd, s, ptralign))
2246 return FALSE;
2247
2248 if (! _bfd_cr16_elf_create_got_section (abfd, info))
2249 return FALSE;
2250
2251 if (bed->want_dynbss)
2252 {
2253 /* The .dynbss section is a place to put symbols which are defined
2254 by dynamic objects, are referenced by regular objects, and are
2255 not functions. We must allocate space for them in the process
2256 image and use a R_*_COPY reloc to tell the dynamic linker to
2257 initialize them at run time. The linker script puts the .dynbss
2258 section into the .bss section of the final image. */
2259 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2260 SEC_ALLOC | SEC_LINKER_CREATED);
2261 if (s == NULL)
2262 return FALSE;
2263
2264 /* The .rel[a].bss section holds copy relocs. This section is not
2265 normally needed. We need to create it here, though, so that the
2266 linker will map it to an output section. We can't just create it
2267 only if we need it, because we will not know whether we need it
2268 until we have seen all the input files, and the first time the
2269 main linker code calls BFD after examining all the input files
2270 (size_dynamic_sections) the input sections have already been
2271 mapped to the output sections. If the section turns out not to
2272 be needed, we can discard it later. We will never need this
2273 section when generating a shared object, since they do not use
2274 copy relocs. */
2275 if (! bfd_link_executable (info))
2276 {
2277 s = bfd_make_section_anyway_with_flags (abfd,
2278 (bed->default_use_rela_p
2279 ? ".rela.bss" : ".rel.bss"),
2280 flags | SEC_READONLY);
2281 if (s == NULL
2282 || ! bfd_set_section_alignment (abfd, s, ptralign))
2283 return FALSE;
2284 }
2285 }
2286
2287 return TRUE;
2288 }
2289 \f
2290 /* Adjust a symbol defined by a dynamic object and referenced by a
2291 regular object. The current definition is in some section of the
2292 dynamic object, but we're not including those sections. We have to
2293 change the definition to something the rest of the link can
2294 understand. */
2295
2296 static bfd_boolean
2297 _bfd_cr16_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
2298 struct elf_link_hash_entry * h)
2299 {
2300 bfd * dynobj;
2301 asection * s;
2302
2303 dynobj = elf_hash_table (info)->dynobj;
2304
2305 /* Make sure we know what is going on here. */
2306 BFD_ASSERT (dynobj != NULL
2307 && (h->needs_plt
2308 || h->is_weakalias
2309 || (h->def_dynamic
2310 && h->ref_regular
2311 && !h->def_regular)));
2312
2313 /* If this is a function, put it in the procedure linkage table. We
2314 will fill in the contents of the procedure linkage table later,
2315 when we know the address of the .got section. */
2316 if (h->type == STT_FUNC
2317 || h->needs_plt)
2318 {
2319 if (! bfd_link_executable (info)
2320 && !h->def_dynamic
2321 && !h->ref_dynamic)
2322 {
2323 /* This case can occur if we saw a PLT reloc in an input
2324 file, but the symbol was never referred to by a dynamic
2325 object. In such a case, we don't actually need to build
2326 a procedure linkage table, and we can just do a REL32
2327 reloc instead. */
2328 BFD_ASSERT (h->needs_plt);
2329 return TRUE;
2330 }
2331
2332 /* Make sure this symbol is output as a dynamic symbol. */
2333 if (h->dynindx == -1)
2334 {
2335 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2336 return FALSE;
2337 }
2338
2339 /* We also need to make an entry in the .got.plt section, which
2340 will be placed in the .got section by the linker script. */
2341
2342 s = elf_hash_table (info)->sgotplt;
2343 BFD_ASSERT (s != NULL);
2344 s->size += 4;
2345
2346 /* We also need to make an entry in the .rela.plt section. */
2347
2348 s = elf_hash_table (info)->srelplt;
2349 BFD_ASSERT (s != NULL);
2350 s->size += sizeof (Elf32_External_Rela);
2351
2352 return TRUE;
2353 }
2354
2355 /* If this is a weak symbol, and there is a real definition, the
2356 processor independent code will have arranged for us to see the
2357 real definition first, and we can just use the same value. */
2358 if (h->is_weakalias)
2359 {
2360 struct elf_link_hash_entry *def = weakdef (h);
2361 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2362 h->root.u.def.section = def->root.u.def.section;
2363 h->root.u.def.value = def->root.u.def.value;
2364 return TRUE;
2365 }
2366
2367 /* This is a reference to a symbol defined by a dynamic object which
2368 is not a function. */
2369
2370 /* If we are creating a shared library, we must presume that the
2371 only references to the symbol are via the global offset table.
2372 For such cases we need not do anything here; the relocations will
2373 be handled correctly by relocate_section. */
2374 if (bfd_link_executable (info))
2375 return TRUE;
2376
2377 /* If there are no references to this symbol that do not use the
2378 GOT, we don't need to generate a copy reloc. */
2379 if (!h->non_got_ref)
2380 return TRUE;
2381
2382 /* We must allocate the symbol in our .dynbss section, which will
2383 become part of the .bss section of the executable. There will be
2384 an entry for this symbol in the .dynsym section. The dynamic
2385 object will contain position independent code, so all references
2386 from the dynamic object to this symbol will go through the global
2387 offset table. The dynamic linker will use the .dynsym entry to
2388 determine the address it must put in the global offset table, so
2389 both the dynamic object and the regular object will refer to the
2390 same memory location for the variable. */
2391
2392 s = bfd_get_linker_section (dynobj, ".dynbss");
2393 BFD_ASSERT (s != NULL);
2394
2395 /* We must generate a R_CR16_COPY reloc to tell the dynamic linker to
2396 copy the initial value out of the dynamic object and into the
2397 runtime process image. We need to remember the offset into the
2398 .rela.bss section we are going to use. */
2399 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2400 {
2401 asection * srel;
2402
2403 srel = bfd_get_linker_section (dynobj, ".rela.bss");
2404 BFD_ASSERT (srel != NULL);
2405 srel->size += sizeof (Elf32_External_Rela);
2406 h->needs_copy = 1;
2407 }
2408
2409 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2410 }
2411
2412 /* Set the sizes of the dynamic sections. */
2413
2414 static bfd_boolean
2415 _bfd_cr16_elf_size_dynamic_sections (bfd * output_bfd,
2416 struct bfd_link_info * info)
2417 {
2418 bfd * dynobj;
2419 asection * s;
2420 bfd_boolean plt;
2421 bfd_boolean relocs;
2422 bfd_boolean reltext;
2423
2424 dynobj = elf_hash_table (info)->dynobj;
2425 BFD_ASSERT (dynobj != NULL);
2426
2427 if (elf_hash_table (info)->dynamic_sections_created)
2428 {
2429 /* Set the contents of the .interp section to the interpreter. */
2430 if (bfd_link_executable (info) && !info->nointerp)
2431 {
2432 #if 0
2433 s = bfd_get_linker_section (dynobj, ".interp");
2434 BFD_ASSERT (s != NULL);
2435 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2436 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2437 #endif
2438 }
2439 }
2440 else
2441 {
2442 /* We may have created entries in the .rela.got section.
2443 However, if we are not creating the dynamic sections, we will
2444 not actually use these entries. Reset the size of .rela.got,
2445 which will cause it to get stripped from the output file
2446 below. */
2447 s = elf_hash_table (info)->srelgot;
2448 if (s != NULL)
2449 s->size = 0;
2450 }
2451
2452 /* The check_relocs and adjust_dynamic_symbol entry points have
2453 determined the sizes of the various dynamic sections. Allocate
2454 memory for them. */
2455 plt = FALSE;
2456 relocs = FALSE;
2457 reltext = FALSE;
2458 for (s = dynobj->sections; s != NULL; s = s->next)
2459 {
2460 const char * name;
2461
2462 if ((s->flags & SEC_LINKER_CREATED) == 0)
2463 continue;
2464
2465 /* It's OK to base decisions on the section name, because none
2466 of the dynobj section names depend upon the input files. */
2467 name = bfd_get_section_name (dynobj, s);
2468
2469 if (strcmp (name, ".plt") == 0)
2470 {
2471 /* Remember whether there is a PLT. */
2472 plt = s->size != 0;
2473 }
2474 else if (CONST_STRNEQ (name, ".rela"))
2475 {
2476 if (s->size != 0)
2477 {
2478 asection * target;
2479
2480 /* Remember whether there are any reloc sections other
2481 than .rela.plt. */
2482 if (strcmp (name, ".rela.plt") != 0)
2483 {
2484 const char * outname;
2485
2486 relocs = TRUE;
2487
2488 /* If this relocation section applies to a read only
2489 section, then we probably need a DT_TEXTREL
2490 entry. The entries in the .rela.plt section
2491 really apply to the .got section, which we
2492 created ourselves and so know is not readonly. */
2493 outname = bfd_get_section_name (output_bfd,
2494 s->output_section);
2495 target = bfd_get_section_by_name (output_bfd, outname + 5);
2496 if (target != NULL
2497 && (target->flags & SEC_READONLY) != 0
2498 && (target->flags & SEC_ALLOC) != 0)
2499 reltext = TRUE;
2500 }
2501
2502 /* We use the reloc_count field as a counter if we need
2503 to copy relocs into the output file. */
2504 s->reloc_count = 0;
2505 }
2506 }
2507 else if (! CONST_STRNEQ (name, ".got")
2508 && strcmp (name, ".dynbss") != 0)
2509 /* It's not one of our sections, so don't allocate space. */
2510 continue;
2511
2512 if (s->size == 0)
2513 {
2514 /* If we don't need this section, strip it from the
2515 output file. This is mostly to handle .rela.bss and
2516 .rela.plt. We must create both sections in
2517 create_dynamic_sections, because they must be created
2518 before the linker maps input sections to output
2519 sections. The linker does that before
2520 adjust_dynamic_symbol is called, and it is that
2521 function which decides whether anything needs to go
2522 into these sections. */
2523 s->flags |= SEC_EXCLUDE;
2524 continue;
2525 }
2526
2527 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2528 continue;
2529
2530 /* Allocate memory for the section contents. We use bfd_zalloc
2531 here in case unused entries are not reclaimed before the
2532 section's contents are written out. This should not happen,
2533 but this way if it does, we get a R_CR16_NONE reloc
2534 instead of garbage. */
2535 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2536 if (s->contents == NULL)
2537 return FALSE;
2538 }
2539
2540 if (elf_hash_table (info)->dynamic_sections_created)
2541 {
2542 /* Add some entries to the .dynamic section. We fill in the
2543 values later, in _bfd_cr16_elf_finish_dynamic_sections,
2544 but we must add the entries now so that we get the correct
2545 size for the .dynamic section. The DT_DEBUG entry is filled
2546 in by the dynamic linker and used by the debugger. */
2547 if (! bfd_link_executable (info))
2548 {
2549 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
2550 return FALSE;
2551 }
2552
2553 if (plt)
2554 {
2555 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
2556 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2557 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
2558 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
2559 return FALSE;
2560 }
2561
2562 if (relocs)
2563 {
2564 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
2565 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
2566 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
2567 sizeof (Elf32_External_Rela)))
2568 return FALSE;
2569 }
2570
2571 if (reltext)
2572 {
2573 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
2574 return FALSE;
2575 }
2576 }
2577
2578 return TRUE;
2579 }
2580
2581 /* Finish up dynamic symbol handling. We set the contents of various
2582 dynamic sections here. */
2583
2584 static bfd_boolean
2585 _bfd_cr16_elf_finish_dynamic_symbol (bfd * output_bfd,
2586 struct bfd_link_info * info,
2587 struct elf_link_hash_entry * h,
2588 Elf_Internal_Sym * sym)
2589 {
2590 bfd * dynobj;
2591
2592 dynobj = elf_hash_table (info)->dynobj;
2593
2594 if (h->got.offset != (bfd_vma) -1)
2595 {
2596 asection * sgot;
2597 asection * srel;
2598 Elf_Internal_Rela rel;
2599
2600 /* This symbol has an entry in the global offset table. Set it up. */
2601
2602 sgot = elf_hash_table (info)->sgot;
2603 srel = elf_hash_table (info)->srelgot;
2604 BFD_ASSERT (sgot != NULL && srel != NULL);
2605
2606 rel.r_offset = (sgot->output_section->vma
2607 + sgot->output_offset
2608 + (h->got.offset & ~1));
2609
2610 /* If this is a -Bsymbolic link, and the symbol is defined
2611 locally, we just want to emit a RELATIVE reloc. Likewise if
2612 the symbol was forced to be local because of a version file.
2613 The entry in the global offset table will already have been
2614 initialized in the relocate_section function. */
2615 if (bfd_link_executable (info)
2616 && (info->symbolic || h->dynindx == -1)
2617 && h->def_regular)
2618 {
2619 rel.r_info = ELF32_R_INFO (0, R_CR16_GOT_REGREL20);
2620 rel.r_addend = (h->root.u.def.value
2621 + h->root.u.def.section->output_section->vma
2622 + h->root.u.def.section->output_offset);
2623 }
2624 else
2625 {
2626 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2627 rel.r_info = ELF32_R_INFO (h->dynindx, R_CR16_GOT_REGREL20);
2628 rel.r_addend = 0;
2629 }
2630
2631 bfd_elf32_swap_reloca_out (output_bfd, &rel,
2632 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
2633 + srel->reloc_count));
2634 ++ srel->reloc_count;
2635 }
2636
2637 if (h->needs_copy)
2638 {
2639 asection * s;
2640 Elf_Internal_Rela rel;
2641
2642 /* This symbol needs a copy reloc. Set it up. */
2643 BFD_ASSERT (h->dynindx != -1
2644 && (h->root.type == bfd_link_hash_defined
2645 || h->root.type == bfd_link_hash_defweak));
2646
2647 s = bfd_get_linker_section (dynobj, ".rela.bss");
2648 BFD_ASSERT (s != NULL);
2649
2650 rel.r_offset = (h->root.u.def.value
2651 + h->root.u.def.section->output_section->vma
2652 + h->root.u.def.section->output_offset);
2653 rel.r_info = ELF32_R_INFO (h->dynindx, R_CR16_GOT_REGREL20);
2654 rel.r_addend = 0;
2655 bfd_elf32_swap_reloca_out (output_bfd, &rel,
2656 (bfd_byte *) ((Elf32_External_Rela *) s->contents
2657 + s->reloc_count));
2658 ++ s->reloc_count;
2659 }
2660
2661 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2662 if (h == elf_hash_table (info)->hdynamic
2663 || h == elf_hash_table (info)->hgot)
2664 sym->st_shndx = SHN_ABS;
2665
2666 return TRUE;
2667 }
2668
2669 /* Finish up the dynamic sections. */
2670
2671 static bfd_boolean
2672 _bfd_cr16_elf_finish_dynamic_sections (bfd * output_bfd,
2673 struct bfd_link_info * info)
2674 {
2675 bfd * dynobj;
2676 asection * sgot;
2677 asection * sdyn;
2678
2679 dynobj = elf_hash_table (info)->dynobj;
2680
2681 sgot = elf_hash_table (info)->sgotplt;
2682 BFD_ASSERT (sgot != NULL);
2683 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2684
2685 if (elf_hash_table (info)->dynamic_sections_created)
2686 {
2687 Elf32_External_Dyn * dyncon;
2688 Elf32_External_Dyn * dynconend;
2689
2690 BFD_ASSERT (sdyn != NULL);
2691
2692 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2693 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2694
2695 for (; dyncon < dynconend; dyncon++)
2696 {
2697 Elf_Internal_Dyn dyn;
2698 asection * s;
2699
2700 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2701
2702 switch (dyn.d_tag)
2703 {
2704 default:
2705 break;
2706
2707 case DT_PLTGOT:
2708 s = elf_hash_table (info)->sgotplt;
2709 goto get_vma;
2710
2711 case DT_JMPREL:
2712 s = elf_hash_table (info)->srelplt;
2713 get_vma:
2714 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2715 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2716 break;
2717
2718 case DT_PLTRELSZ:
2719 s = elf_hash_table (info)->srelplt;
2720 dyn.d_un.d_val = s->size;
2721 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2722 break;
2723 }
2724 }
2725
2726 }
2727
2728 /* Fill in the first three entries in the global offset table. */
2729 if (sgot->size > 0)
2730 {
2731 if (sdyn == NULL)
2732 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2733 else
2734 bfd_put_32 (output_bfd,
2735 sdyn->output_section->vma + sdyn->output_offset,
2736 sgot->contents);
2737 }
2738
2739 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2740
2741 return TRUE;
2742 }
2743
2744 /* Given a .data.rel section and a .emreloc in-memory section, store
2745 relocation information into the .emreloc section which can be
2746 used at runtime to relocate the section. This is called by the
2747 linker when the --embedded-relocs switch is used. This is called
2748 after the add_symbols entry point has been called for all the
2749 objects, and before the final_link entry point is called. */
2750
2751 bfd_boolean
2752 bfd_cr16_elf32_create_embedded_relocs (bfd *abfd,
2753 struct bfd_link_info *info,
2754 asection *datasec,
2755 asection *relsec,
2756 char **errmsg)
2757 {
2758 Elf_Internal_Shdr *symtab_hdr;
2759 Elf_Internal_Sym *isymbuf = NULL;
2760 Elf_Internal_Rela *internal_relocs = NULL;
2761 Elf_Internal_Rela *irel, *irelend;
2762 bfd_byte *p;
2763 bfd_size_type amt;
2764
2765 BFD_ASSERT (! bfd_link_relocatable (info));
2766
2767 *errmsg = NULL;
2768
2769 if (datasec->reloc_count == 0)
2770 return TRUE;
2771
2772 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2773
2774 /* Get a copy of the native relocations. */
2775 internal_relocs = (_bfd_elf_link_read_relocs
2776 (abfd, datasec, NULL, NULL, info->keep_memory));
2777 if (internal_relocs == NULL)
2778 goto error_return;
2779
2780 amt = (bfd_size_type) datasec->reloc_count * 8;
2781 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2782 if (relsec->contents == NULL)
2783 goto error_return;
2784
2785 p = relsec->contents;
2786
2787 irelend = internal_relocs + datasec->reloc_count;
2788 for (irel = internal_relocs; irel < irelend; irel++, p += 8)
2789 {
2790 asection *targetsec;
2791
2792 /* We are going to write a four byte longword into the runtime
2793 reloc section. The longword will be the address in the data
2794 section which must be relocated. It is followed by the name
2795 of the target section NUL-padded or truncated to 8
2796 characters. */
2797
2798 /* We can only relocate absolute longword relocs at run time. */
2799 if (!((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32a)
2800 || (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32)))
2801 {
2802 *errmsg = _("unsupported relocation type");
2803 bfd_set_error (bfd_error_bad_value);
2804 goto error_return;
2805 }
2806
2807 /* Get the target section referred to by the reloc. */
2808 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2809 {
2810 /* A local symbol. */
2811 Elf_Internal_Sym *isym;
2812
2813 /* Read this BFD's local symbols if we haven't done so already. */
2814 if (isymbuf == NULL)
2815 {
2816 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2817 if (isymbuf == NULL)
2818 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2819 symtab_hdr->sh_info, 0,
2820 NULL, NULL, NULL);
2821 if (isymbuf == NULL)
2822 goto error_return;
2823 }
2824
2825 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2826 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2827 }
2828 else
2829 {
2830 unsigned long indx;
2831 struct elf_link_hash_entry *h;
2832
2833 /* An external symbol. */
2834 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2835 h = elf_sym_hashes (abfd)[indx];
2836 BFD_ASSERT (h != NULL);
2837 if (h->root.type == bfd_link_hash_defined
2838 || h->root.type == bfd_link_hash_defweak)
2839 targetsec = h->root.u.def.section;
2840 else
2841 targetsec = NULL;
2842 }
2843
2844 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
2845 memset (p + 4, 0, 4);
2846 if ((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32a)
2847 && (targetsec != NULL) )
2848 strncpy ((char *) p + 4, targetsec->output_section->name, 4);
2849 }
2850
2851 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2852 free (isymbuf);
2853 if (internal_relocs != NULL
2854 && elf_section_data (datasec)->relocs != internal_relocs)
2855 free (internal_relocs);
2856 return TRUE;
2857
2858 error_return:
2859 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2860 free (isymbuf);
2861 if (internal_relocs != NULL
2862 && elf_section_data (datasec)->relocs != internal_relocs)
2863 free (internal_relocs);
2864 return FALSE;
2865 }
2866
2867
2868 /* Classify relocation types, such that combreloc can sort them
2869 properly. */
2870
2871 static enum elf_reloc_type_class
2872 _bfd_cr16_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2873 const asection *rel_sec ATTRIBUTE_UNUSED,
2874 const Elf_Internal_Rela *rela)
2875 {
2876 switch ((int) ELF32_R_TYPE (rela->r_info))
2877 {
2878 case R_CR16_GOT_REGREL20:
2879 case R_CR16_GOTC_REGREL20:
2880 return reloc_class_relative;
2881 default:
2882 return reloc_class_normal;
2883 }
2884 }
2885
2886 /* Definitions for setting CR16 target vector. */
2887 #define TARGET_LITTLE_SYM cr16_elf32_vec
2888 #define TARGET_LITTLE_NAME "elf32-cr16"
2889 #define ELF_ARCH bfd_arch_cr16
2890 #define ELF_MACHINE_CODE EM_CR16
2891 #define ELF_MACHINE_ALT1 EM_CR16_OLD
2892 #define ELF_MAXPAGESIZE 0x1
2893 #define elf_symbol_leading_char '_'
2894
2895 #define bfd_elf32_bfd_reloc_type_lookup elf_cr16_reloc_type_lookup
2896 #define bfd_elf32_bfd_reloc_name_lookup elf_cr16_reloc_name_lookup
2897 #define elf_info_to_howto elf_cr16_info_to_howto
2898 #define elf_info_to_howto_rel 0
2899 #define elf_backend_relocate_section elf32_cr16_relocate_section
2900 #define bfd_elf32_bfd_relax_section elf32_cr16_relax_section
2901 #define bfd_elf32_bfd_get_relocated_section_contents \
2902 elf32_cr16_get_relocated_section_contents
2903 #define elf_backend_gc_mark_hook elf32_cr16_gc_mark_hook
2904 #define elf_backend_can_gc_sections 1
2905 #define elf_backend_rela_normal 1
2906 #define elf_backend_check_relocs cr16_elf_check_relocs
2907 /* So we can set bits in e_flags. */
2908 #define elf_backend_final_write_processing \
2909 _bfd_cr16_elf_final_write_processing
2910 #define elf_backend_object_p _bfd_cr16_elf_object_p
2911
2912 #define bfd_elf32_bfd_merge_private_bfd_data \
2913 _bfd_cr16_elf_merge_private_bfd_data
2914
2915
2916 #define bfd_elf32_bfd_link_hash_table_create \
2917 elf32_cr16_link_hash_table_create
2918
2919 #define elf_backend_create_dynamic_sections \
2920 _bfd_cr16_elf_create_dynamic_sections
2921 #define elf_backend_adjust_dynamic_symbol \
2922 _bfd_cr16_elf_adjust_dynamic_symbol
2923 #define elf_backend_size_dynamic_sections \
2924 _bfd_cr16_elf_size_dynamic_sections
2925 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
2926 #define elf_backend_finish_dynamic_symbol \
2927 _bfd_cr16_elf_finish_dynamic_symbol
2928 #define elf_backend_finish_dynamic_sections \
2929 _bfd_cr16_elf_finish_dynamic_sections
2930
2931 #define elf_backend_reloc_type_class _bfd_cr16_elf_reloc_type_class
2932
2933
2934 #define elf_backend_want_got_plt 1
2935 #define elf_backend_plt_readonly 1
2936 #define elf_backend_want_plt_sym 0
2937 #define elf_backend_got_header_size 12
2938 #define elf_backend_dtrel_excludes_plt 1
2939
2940 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.087369 seconds and 5 git commands to generate.