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