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