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