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