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