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