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