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