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