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