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