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