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