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