projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
AArch64: Mark sve instructions that require MOVPRFX constraints
[deliverable/binutils-gdb.git] / bfd / elf32-rl78.c
1 /* Renesas RL78 specific support for 32-bit ELF.
2 Copyright (C) 2011-2018 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "bfd_stdint.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/rl78.h"
27 #include "libiberty.h"
28
29 #define valid_16bit_address(v) ((v) <= 0x0ffff || (v) >= 0xf0000)
30
31 #define RL78REL(n,sz,bit,shift,complain,pcrel) \
32 HOWTO (R_RL78_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
33 bfd_elf_generic_reloc, "R_RL78_" #n, FALSE, 0, ~0, FALSE)
34
35 static bfd_reloc_status_type rl78_special_reloc (bfd *, arelent *, asymbol *, void *,
36 asection *, bfd *, char **);
37
38 /* FIXME: We could omit the SHIFT parameter, it is always zero. */
39 #define RL78_OP_REL(n,sz,bit,shift,complain,pcrel) \
40 HOWTO (R_RL78_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
41 rl78_special_reloc, "R_RL78_" #n, FALSE, 0, ~0, FALSE)
42
43 /* Note that the relocations around 0x7f are internal to this file;
44 feel free to move them as needed to avoid conflicts with published
45 relocation numbers. */
46
47 static reloc_howto_type rl78_elf_howto_table [] =
48 {
49 RL78REL (NONE, 3, 0, 0, dont, FALSE),
50 RL78REL (DIR32, 2, 32, 0, signed, FALSE),
51 RL78REL (DIR24S, 2, 24, 0, signed, FALSE),
52 RL78REL (DIR16, 1, 16, 0, dont, FALSE),
53 RL78REL (DIR16U, 1, 16, 0, unsigned, FALSE),
54 RL78REL (DIR16S, 1, 16, 0, signed, FALSE),
55 RL78REL (DIR8, 0, 8, 0, dont, FALSE),
56 RL78REL (DIR8U, 0, 8, 0, unsigned, FALSE),
57 RL78REL (DIR8S, 0, 8, 0, signed, FALSE),
58 RL78REL (DIR24S_PCREL, 2, 24, 0, signed, TRUE),
59 RL78REL (DIR16S_PCREL, 1, 16, 0, signed, TRUE),
60 RL78REL (DIR8S_PCREL, 0, 8, 0, signed, TRUE),
61 RL78REL (DIR16UL, 1, 16, 2, unsigned, FALSE),
62 RL78REL (DIR16UW, 1, 16, 1, unsigned, FALSE),
63 RL78REL (DIR8UL, 0, 8, 2, unsigned, FALSE),
64 RL78REL (DIR8UW, 0, 8, 1, unsigned, FALSE),
65 RL78REL (DIR32_REV, 1, 16, 0, dont, FALSE),
66 RL78REL (DIR16_REV, 1, 16, 0, dont, FALSE),
67 RL78REL (DIR3U_PCREL, 0, 3, 0, dont, TRUE),
68
69 EMPTY_HOWTO (0x13),
70 EMPTY_HOWTO (0x14),
71 EMPTY_HOWTO (0x15),
72 EMPTY_HOWTO (0x16),
73 EMPTY_HOWTO (0x17),
74 EMPTY_HOWTO (0x18),
75 EMPTY_HOWTO (0x19),
76 EMPTY_HOWTO (0x1a),
77 EMPTY_HOWTO (0x1b),
78 EMPTY_HOWTO (0x1c),
79 EMPTY_HOWTO (0x1d),
80 EMPTY_HOWTO (0x1e),
81 EMPTY_HOWTO (0x1f),
82
83 EMPTY_HOWTO (0x20),
84 EMPTY_HOWTO (0x21),
85 EMPTY_HOWTO (0x22),
86 EMPTY_HOWTO (0x23),
87 EMPTY_HOWTO (0x24),
88 EMPTY_HOWTO (0x25),
89 EMPTY_HOWTO (0x26),
90 EMPTY_HOWTO (0x27),
91 EMPTY_HOWTO (0x28),
92 EMPTY_HOWTO (0x29),
93 EMPTY_HOWTO (0x2a),
94 EMPTY_HOWTO (0x2b),
95 EMPTY_HOWTO (0x2c),
96 RL78REL (RH_RELAX, 0, 0, 0, dont, FALSE),
97
98 EMPTY_HOWTO (0x2e),
99 RL78REL (RH_SADDR, 0, 0, 0, dont, FALSE),
100 EMPTY_HOWTO (0x30),
101 EMPTY_HOWTO (0x31),
102 EMPTY_HOWTO (0x32),
103 EMPTY_HOWTO (0x33),
104 EMPTY_HOWTO (0x34),
105 EMPTY_HOWTO (0x35),
106 EMPTY_HOWTO (0x36),
107 EMPTY_HOWTO (0x37),
108 EMPTY_HOWTO (0x38),
109 EMPTY_HOWTO (0x39),
110 EMPTY_HOWTO (0x3a),
111 EMPTY_HOWTO (0x3b),
112 EMPTY_HOWTO (0x3c),
113 EMPTY_HOWTO (0x3d),
114 EMPTY_HOWTO (0x3e),
115 EMPTY_HOWTO (0x3f),
116 EMPTY_HOWTO (0x40),
117
118 RL78_OP_REL (ABS32, 2, 32, 0, dont, FALSE),
119 RL78_OP_REL (ABS24S, 2, 24, 0, signed, FALSE),
120 RL78_OP_REL (ABS16, 1, 16, 0, dont, FALSE),
121 RL78_OP_REL (ABS16U, 1, 16, 0, unsigned, FALSE),
122 RL78_OP_REL (ABS16S, 1, 16, 0, signed, FALSE),
123 RL78_OP_REL (ABS8, 0, 8, 0, dont, FALSE),
124 RL78_OP_REL (ABS8U, 0, 8, 0, unsigned, FALSE),
125 RL78_OP_REL (ABS8S, 0, 8, 0, signed, FALSE),
126 RL78_OP_REL (ABS24S_PCREL, 2, 24, 0, signed, TRUE),
127 RL78_OP_REL (ABS16S_PCREL, 1, 16, 0, signed, TRUE),
128 RL78_OP_REL (ABS8S_PCREL, 0, 8, 0, signed, TRUE),
129 RL78_OP_REL (ABS16UL, 1, 16, 0, unsigned, FALSE),
130 RL78_OP_REL (ABS16UW, 1, 16, 0, unsigned, FALSE),
131 RL78_OP_REL (ABS8UL, 0, 8, 0, unsigned, FALSE),
132 RL78_OP_REL (ABS8UW, 0, 8, 0, unsigned, FALSE),
133 RL78_OP_REL (ABS32_REV, 2, 32, 0, dont, FALSE),
134 RL78_OP_REL (ABS16_REV, 1, 16, 0, dont, FALSE),
135
136 #define STACK_REL_P(x) ((x) <= R_RL78_ABS16_REV && (x) >= R_RL78_ABS32)
137
138 EMPTY_HOWTO (0x52),
139 EMPTY_HOWTO (0x53),
140 EMPTY_HOWTO (0x54),
141 EMPTY_HOWTO (0x55),
142 EMPTY_HOWTO (0x56),
143 EMPTY_HOWTO (0x57),
144 EMPTY_HOWTO (0x58),
145 EMPTY_HOWTO (0x59),
146 EMPTY_HOWTO (0x5a),
147 EMPTY_HOWTO (0x5b),
148 EMPTY_HOWTO (0x5c),
149 EMPTY_HOWTO (0x5d),
150 EMPTY_HOWTO (0x5e),
151 EMPTY_HOWTO (0x5f),
152 EMPTY_HOWTO (0x60),
153 EMPTY_HOWTO (0x61),
154 EMPTY_HOWTO (0x62),
155 EMPTY_HOWTO (0x63),
156 EMPTY_HOWTO (0x64),
157 EMPTY_HOWTO (0x65),
158 EMPTY_HOWTO (0x66),
159 EMPTY_HOWTO (0x67),
160 EMPTY_HOWTO (0x68),
161 EMPTY_HOWTO (0x69),
162 EMPTY_HOWTO (0x6a),
163 EMPTY_HOWTO (0x6b),
164 EMPTY_HOWTO (0x6c),
165 EMPTY_HOWTO (0x6d),
166 EMPTY_HOWTO (0x6e),
167 EMPTY_HOWTO (0x6f),
168 EMPTY_HOWTO (0x70),
169 EMPTY_HOWTO (0x71),
170 EMPTY_HOWTO (0x72),
171 EMPTY_HOWTO (0x73),
172 EMPTY_HOWTO (0x74),
173 EMPTY_HOWTO (0x75),
174 EMPTY_HOWTO (0x76),
175 EMPTY_HOWTO (0x77),
176
177 EMPTY_HOWTO (0x78),
178 EMPTY_HOWTO (0x79),
179 EMPTY_HOWTO (0x7a),
180 EMPTY_HOWTO (0x7b),
181 EMPTY_HOWTO (0x7c),
182 EMPTY_HOWTO (0x7d),
183 EMPTY_HOWTO (0x7e),
184 EMPTY_HOWTO (0x7f),
185
186 RL78_OP_REL (SYM, 2, 32, 0, dont, FALSE),
187 RL78_OP_REL (OPneg, 2, 32, 0, dont, FALSE),
188 RL78_OP_REL (OPadd, 2, 32, 0, dont, FALSE),
189 RL78_OP_REL (OPsub, 2, 32, 0, dont, FALSE),
190 RL78_OP_REL (OPmul, 2, 32, 0, dont, FALSE),
191 RL78_OP_REL (OPdiv, 2, 32, 0, dont, FALSE),
192 RL78_OP_REL (OPshla, 2, 32, 0, dont, FALSE),
193 RL78_OP_REL (OPshra, 2, 32, 0, dont, FALSE),
194 RL78_OP_REL (OPsctsize, 2, 32, 0, dont, FALSE),
195 EMPTY_HOWTO (0x89),
196 EMPTY_HOWTO (0x8a),
197 EMPTY_HOWTO (0x8b),
198 EMPTY_HOWTO (0x8c),
199 RL78_OP_REL (OPscttop, 2, 32, 0, dont, FALSE),
200 EMPTY_HOWTO (0x8e),
201 EMPTY_HOWTO (0x8f),
202 RL78_OP_REL (OPand, 2, 32, 0, dont, FALSE),
203 RL78_OP_REL (OPor, 2, 32, 0, dont, FALSE),
204 RL78_OP_REL (OPxor, 2, 32, 0, dont, FALSE),
205 RL78_OP_REL (OPnot, 2, 32, 0, dont, FALSE),
206 RL78_OP_REL (OPmod, 2, 32, 0, dont, FALSE),
207 RL78_OP_REL (OPromtop, 2, 32, 0, dont, FALSE),
208 RL78_OP_REL (OPramtop, 2, 32, 0, dont, FALSE)
209 };
210 \f
211 /* Map BFD reloc types to RL78 ELF reloc types. */
212
213 struct rl78_reloc_map
214 {
215 bfd_reloc_code_real_type bfd_reloc_val;
216 unsigned int rl78_reloc_val;
217 };
218
219 static const struct rl78_reloc_map rl78_reloc_map [] =
220 {
221 { BFD_RELOC_NONE, R_RL78_NONE },
222 { BFD_RELOC_8, R_RL78_DIR8S },
223 { BFD_RELOC_16, R_RL78_DIR16S },
224 { BFD_RELOC_24, R_RL78_DIR24S },
225 { BFD_RELOC_32, R_RL78_DIR32 },
226 { BFD_RELOC_RL78_16_OP, R_RL78_DIR16 },
227 { BFD_RELOC_RL78_DIR3U_PCREL, R_RL78_DIR3U_PCREL },
228 { BFD_RELOC_8_PCREL, R_RL78_DIR8S_PCREL },
229 { BFD_RELOC_16_PCREL, R_RL78_DIR16S_PCREL },
230 { BFD_RELOC_24_PCREL, R_RL78_DIR24S_PCREL },
231 { BFD_RELOC_RL78_8U, R_RL78_DIR8U },
232 { BFD_RELOC_RL78_16U, R_RL78_DIR16U },
233 { BFD_RELOC_RL78_SYM, R_RL78_SYM },
234 { BFD_RELOC_RL78_OP_SUBTRACT, R_RL78_OPsub },
235 { BFD_RELOC_RL78_OP_NEG, R_RL78_OPneg },
236 { BFD_RELOC_RL78_OP_AND, R_RL78_OPand },
237 { BFD_RELOC_RL78_OP_SHRA, R_RL78_OPshra },
238 { BFD_RELOC_RL78_ABS8, R_RL78_ABS8 },
239 { BFD_RELOC_RL78_ABS16, R_RL78_ABS16 },
240 { BFD_RELOC_RL78_ABS16_REV, R_RL78_ABS16_REV },
241 { BFD_RELOC_RL78_ABS32, R_RL78_ABS32 },
242 { BFD_RELOC_RL78_ABS32_REV, R_RL78_ABS32_REV },
243 { BFD_RELOC_RL78_ABS16UL, R_RL78_ABS16UL },
244 { BFD_RELOC_RL78_ABS16UW, R_RL78_ABS16UW },
245 { BFD_RELOC_RL78_ABS16U, R_RL78_ABS16U },
246 { BFD_RELOC_RL78_SADDR, R_RL78_RH_SADDR },
247 { BFD_RELOC_RL78_RELAX, R_RL78_RH_RELAX }
248 };
249
250 static reloc_howto_type *
251 rl78_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
252 bfd_reloc_code_real_type code)
253 {
254 unsigned int i;
255
256 if (code == BFD_RELOC_RL78_32_OP)
257 return rl78_elf_howto_table + R_RL78_DIR32;
258
259 for (i = ARRAY_SIZE (rl78_reloc_map); i--;)
260 if (rl78_reloc_map [i].bfd_reloc_val == code)
261 return rl78_elf_howto_table + rl78_reloc_map[i].rl78_reloc_val;
262
263 return NULL;
264 }
265
266 static reloc_howto_type *
267 rl78_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, const char * r_name)
268 {
269 unsigned int i;
270
271 for (i = 0; i < ARRAY_SIZE (rl78_elf_howto_table); i++)
272 if (rl78_elf_howto_table[i].name != NULL
273 && strcasecmp (rl78_elf_howto_table[i].name, r_name) == 0)
274 return rl78_elf_howto_table + i;
275
276 return NULL;
277 }
278
279 /* Set the howto pointer for an RL78 ELF reloc. */
280
281 static bfd_boolean
282 rl78_info_to_howto_rela (bfd * abfd,
283 arelent * cache_ptr,
284 Elf_Internal_Rela * dst)
285 {
286 unsigned int r_type;
287
288 r_type = ELF32_R_TYPE (dst->r_info);
289 if (r_type >= (unsigned int) R_RL78_max)
290 {
291 /* xgettext:c-format */
292 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
293 abfd, r_type);
294 bfd_set_error (bfd_error_bad_value);
295 return FALSE;
296 }
297 cache_ptr->howto = rl78_elf_howto_table + r_type;
298 return TRUE;
299 }
300 \f
301 static bfd_vma
302 get_symbol_value (const char * name,
303 struct bfd_link_info * info,
304 bfd * input_bfd,
305 asection * input_section,
306 int offset)
307 {
308 struct bfd_link_hash_entry * h;
309
310 if (info == NULL)
311 return 0;
312
313 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
314
315 if (h == NULL
316 || (h->type != bfd_link_hash_defined
317 && h->type != bfd_link_hash_defweak))
318 {
319 (*info->callbacks->undefined_symbol)
320 (info, name, input_bfd, input_section, offset, TRUE);
321 return 0;
322 }
323
324 return (h->u.def.value
325 + h->u.def.section->output_section->vma
326 + h->u.def.section->output_offset);
327 }
328
329 static bfd_vma
330 get_romstart (struct bfd_link_info * info,
331 bfd * abfd,
332 asection * sec,
333 int offset)
334 {
335 static bfd_boolean cached = FALSE;
336 static bfd_vma cached_value = 0;
337
338 if (!cached)
339 {
340 cached_value = get_symbol_value ("_start", info, abfd, sec, offset);
341 cached = TRUE;
342 }
343 return cached_value;
344 }
345
346 static bfd_vma
347 get_ramstart (struct bfd_link_info * info,
348 bfd * abfd,
349 asection * sec,
350 int offset)
351 {
352 static bfd_boolean cached = FALSE;
353 static bfd_vma cached_value = 0;
354
355 if (!cached)
356 {
357 cached_value = get_symbol_value ("__datastart", info, abfd, sec, offset);
358 cached = TRUE;
359 }
360 return cached_value;
361 }
362
363 #define NUM_STACK_ENTRIES 16
364 static int32_t rl78_stack [ NUM_STACK_ENTRIES ];
365 static unsigned int rl78_stack_top;
366
367 #define RL78_STACK_PUSH(val) \
368 do \
369 { \
370 if (rl78_stack_top < NUM_STACK_ENTRIES) \
371 rl78_stack [rl78_stack_top ++] = (val); \
372 else \
373 _bfd_error_handler (_("internal error: RL78 reloc stack overflow")); \
374 } \
375 while (0)
376
377 #define RL78_STACK_POP(dest) \
378 do \
379 { \
380 if (rl78_stack_top > 0) \
381 (dest) = rl78_stack [-- rl78_stack_top];\
382 else \
383 { \
384 _bfd_error_handler (_("internal error: RL78 reloc stack underflow")); \
385 (dest) = 0; \
386 } \
387 } \
388 while (0)
389
390 /* Special handling for RL78 complex relocs. Returns the
391 value of the reloc, or 0 for relocs which do not generate
392 a result. SYMVAL is the value of the symbol for relocs
393 which use a symbolic argument. */
394
395 static bfd_vma
396 rl78_compute_complex_reloc (unsigned long r_type,
397 bfd_vma symval,
398 asection * input_section)
399 {
400 int32_t tmp1, tmp2;
401 bfd_vma relocation;
402
403 switch (r_type)
404 {
405 default:
406 return 0;
407
408 case R_RL78_ABS24S_PCREL:
409 case R_RL78_ABS16S_PCREL:
410 case R_RL78_ABS8S_PCREL:
411 RL78_STACK_POP (relocation);
412 relocation -= input_section->output_section->vma + input_section->output_offset;
413 return relocation;
414
415 case R_RL78_ABS32:
416 case R_RL78_ABS32_REV:
417 case R_RL78_ABS16:
418 case R_RL78_ABS16_REV:
419 case R_RL78_ABS16S:
420 case R_RL78_ABS16U:
421 case R_RL78_ABS8:
422 case R_RL78_ABS8U:
423 case R_RL78_ABS8S:
424 RL78_STACK_POP (relocation);
425 return relocation;
426
427 case R_RL78_ABS16UL:
428 case R_RL78_ABS8UL:
429 RL78_STACK_POP (relocation);
430 return relocation >> 2;
431
432 case R_RL78_ABS16UW:
433 case R_RL78_ABS8UW:
434 RL78_STACK_POP (relocation);
435 return relocation >> 1;
436
437 /* The rest of the relocs compute values and then push them onto the stack. */
438 case R_RL78_OPramtop:
439 case R_RL78_OPromtop:
440 case R_RL78_SYM:
441 RL78_STACK_PUSH (symval);
442 return 0;
443
444 case R_RL78_OPneg:
445 RL78_STACK_POP (tmp1);
446 tmp1 = - tmp1;
447 RL78_STACK_PUSH (tmp1);
448 return 0;
449
450 case R_RL78_OPadd:
451 RL78_STACK_POP (tmp2);
452 RL78_STACK_POP (tmp1);
453 tmp1 += tmp2;
454 RL78_STACK_PUSH (tmp1);
455 return 0;
456
457 case R_RL78_OPsub:
458 /* For the expression "A - B", the assembler pushes A,
459 then B, then OPSUB. So the first op we pop is B, not A. */
460 RL78_STACK_POP (tmp2); /* B */
461 RL78_STACK_POP (tmp1); /* A */
462 tmp1 -= tmp2; /* A - B */
463 RL78_STACK_PUSH (tmp1);
464 return 0;
465
466 case R_RL78_OPmul:
467 RL78_STACK_POP (tmp2);
468 RL78_STACK_POP (tmp1);
469 tmp1 *= tmp2;
470 RL78_STACK_PUSH (tmp1);
471 return 0;
472
473 case R_RL78_OPdiv:
474 RL78_STACK_POP (tmp2);
475 RL78_STACK_POP (tmp1);
476 tmp1 /= tmp2;
477 RL78_STACK_PUSH (tmp1);
478 return 0;
479
480 case R_RL78_OPshla:
481 RL78_STACK_POP (tmp2);
482 RL78_STACK_POP (tmp1);
483 tmp1 <<= tmp2;
484 RL78_STACK_PUSH (tmp1);
485 return 0;
486
487 case R_RL78_OPshra:
488 RL78_STACK_POP (tmp2);
489 RL78_STACK_POP (tmp1);
490 tmp1 >>= tmp2;
491 RL78_STACK_PUSH (tmp1);
492 return 0;
493
494 case R_RL78_OPsctsize:
495 RL78_STACK_PUSH (input_section->size);
496 return 0;
497
498 case R_RL78_OPscttop:
499 RL78_STACK_PUSH (input_section->output_section->vma);
500 return 0;
501
502 case R_RL78_OPand:
503 RL78_STACK_POP (tmp2);
504 RL78_STACK_POP (tmp1);
505 tmp1 &= tmp2;
506 RL78_STACK_PUSH (tmp1);
507 return 0;
508
509 case R_RL78_OPor:
510 RL78_STACK_POP (tmp2);
511 RL78_STACK_POP (tmp1);
512 tmp1 |= tmp2;
513 RL78_STACK_PUSH (tmp1);
514 return 0;
515
516 case R_RL78_OPxor:
517 RL78_STACK_POP (tmp2);
518 RL78_STACK_POP (tmp1);
519 tmp1 ^= tmp2;
520 RL78_STACK_PUSH (tmp1);
521 return 0;
522
523 case R_RL78_OPnot:
524 RL78_STACK_POP (tmp1);
525 tmp1 = ~ tmp1;
526 RL78_STACK_PUSH (tmp1);
527 return 0;
528
529 case R_RL78_OPmod:
530 RL78_STACK_POP (tmp2);
531 RL78_STACK_POP (tmp1);
532 tmp1 %= tmp2;
533 RL78_STACK_PUSH (tmp1);
534 return 0;
535 }
536 }
537
538 #undef RL78_STACK_PUSH
539 #undef RL78_STACK_POP
540
541 #define OP(i) (contents[reloc->address + (i)])
542
543 static bfd_reloc_status_type
544 rl78_special_reloc (bfd * input_bfd,
545 arelent * reloc,
546 asymbol * symbol,
547 void * data,
548 asection * input_section,
549 bfd * output_bfd ATTRIBUTE_UNUSED,
550 char ** error_message ATTRIBUTE_UNUSED)
551 {
552 bfd_reloc_status_type r = bfd_reloc_ok;
553 bfd_vma relocation = 0;
554 unsigned long r_type = reloc->howto->type;
555 bfd_byte * contents = data;
556
557 /* If necessary, compute the symbolic value of the relocation. */
558 switch (r_type)
559 {
560 case R_RL78_SYM:
561 relocation = (symbol->value
562 + symbol->section->output_section->vma
563 + symbol->section->output_offset
564 + reloc->addend);
565 break;
566
567 case R_RL78_OPromtop:
568 relocation = get_romstart (NULL, input_bfd, input_section,
569 reloc->address);
570 break;
571
572 case R_RL78_OPramtop:
573 relocation = get_ramstart (NULL, input_bfd, input_section,
574 reloc->address);
575 break;
576 }
577
578 /* Get the value of the relocation. */
579 relocation = rl78_compute_complex_reloc (r_type, relocation, input_section);
580
581 /* If the relocation alters the contents of the section then apply it now.
582 Note - since this function is called from
583 bfd_generic_get_relocated_section_contents via bfd_perform_relocation,
584 and not from the linker, we do not perform any range checking. The
585 clients who are calling us are only interested in some relocated section
586 contents, and not any linkage problems that might occur later. */
587 switch (r_type)
588 {
589 case R_RL78_ABS32:
590 OP (0) = relocation;
591 OP (1) = relocation >> 8;
592 OP (2) = relocation >> 16;
593 OP (3) = relocation >> 24;
594 break;
595
596 case R_RL78_ABS32_REV:
597 OP (3) = relocation;
598 OP (2) = relocation >> 8;
599 OP (1) = relocation >> 16;
600 OP (0) = relocation >> 24;
601 break;
602
603 case R_RL78_ABS24S_PCREL:
604 case R_RL78_ABS24S:
605 OP (0) = relocation;
606 OP (1) = relocation >> 8;
607 OP (2) = relocation >> 16;
608 break;
609
610 case R_RL78_ABS16_REV:
611 OP (1) = relocation;
612 OP (0) = relocation >> 8;
613 break;
614
615 case R_RL78_ABS16S_PCREL:
616 case R_RL78_ABS16:
617 case R_RL78_ABS16S:
618 case R_RL78_ABS16U:
619 case R_RL78_ABS16UL:
620 case R_RL78_ABS16UW:
621 OP (0) = relocation;
622 OP (1) = relocation >> 8;
623 break;
624
625 case R_RL78_ABS8S_PCREL:
626 case R_RL78_ABS8:
627 case R_RL78_ABS8U:
628 case R_RL78_ABS8UL:
629 case R_RL78_ABS8UW:
630 case R_RL78_ABS8S:
631 OP (0) = relocation;
632 break;
633
634 default:
635 break;
636 }
637
638 return r;
639 }
640
641 #undef OP
642 #define OP(i) (contents[rel->r_offset + (i)])
643
644 /* Relocate an RL78 ELF section.
645 There is some attempt to make this function usable for many architectures,
646 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
647 if only to serve as a learning tool.
648
649 The RELOCATE_SECTION function is called by the new ELF backend linker
650 to handle the relocations for a section.
651
652 The relocs are always passed as Rela structures; if the section
653 actually uses Rel structures, the r_addend field will always be
654 zero.
655
656 This function is responsible for adjusting the section contents as
657 necessary, and (if using Rela relocs and generating a relocatable
658 output file) adjusting the reloc addend as necessary.
659
660 This function does not have to worry about setting the reloc
661 address or the reloc symbol index.
662
663 LOCAL_SYMS is a pointer to the swapped in local symbols.
664
665 LOCAL_SECTIONS is an array giving the section in the input file
666 corresponding to the st_shndx field of each local symbol.
667
668 The global hash table entry for the global symbols can be found
669 via elf_sym_hashes (input_bfd).
670
671 When generating relocatable output, this function must handle
672 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
673 going to be the section symbol corresponding to the output
674 section, which means that the addend must be adjusted
675 accordingly. */
676
677 static bfd_boolean
678 rl78_elf_relocate_section
679 (bfd * output_bfd,
680 struct bfd_link_info * info,
681 bfd * input_bfd,
682 asection * input_section,
683 bfd_byte * contents,
684 Elf_Internal_Rela * relocs,
685 Elf_Internal_Sym * local_syms,
686 asection ** local_sections)
687 {
688 Elf_Internal_Shdr * symtab_hdr;
689 struct elf_link_hash_entry ** sym_hashes;
690 Elf_Internal_Rela * rel;
691 Elf_Internal_Rela * relend;
692 asection *splt;
693
694 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
695 sym_hashes = elf_sym_hashes (input_bfd);
696 relend = relocs + input_section->reloc_count;
697
698 splt = elf_hash_table (info)->splt;
699
700 for (rel = relocs; rel < relend; rel ++)
701 {
702 reloc_howto_type * howto;
703 unsigned long r_symndx;
704 Elf_Internal_Sym * sym;
705 asection * sec;
706 struct elf_link_hash_entry * h;
707 bfd_vma relocation;
708 bfd_reloc_status_type r;
709 const char * name = NULL;
710 bfd_boolean unresolved_reloc = TRUE;
711 int r_type;
712
713 r_type = ELF32_R_TYPE (rel->r_info);
714 r_symndx = ELF32_R_SYM (rel->r_info);
715
716 howto = rl78_elf_howto_table + ELF32_R_TYPE (rel->r_info);
717 h = NULL;
718 sym = NULL;
719 sec = NULL;
720 relocation = 0;
721
722 if (r_symndx < symtab_hdr->sh_info)
723 {
724 sym = local_syms + r_symndx;
725 sec = local_sections [r_symndx];
726 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
727
728 name = bfd_elf_string_from_elf_section
729 (input_bfd, symtab_hdr->sh_link, sym->st_name);
730 name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
731 }
732 else
733 {
734 bfd_boolean warned ATTRIBUTE_UNUSED;
735 bfd_boolean ignored ATTRIBUTE_UNUSED;
736
737 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
738 r_symndx, symtab_hdr, sym_hashes, h,
739 sec, relocation, unresolved_reloc,
740 warned, ignored);
741
742 name = h->root.root.string;
743 }
744
745 if (sec != NULL && discarded_section (sec))
746 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
747 rel, 1, relend, howto, 0, contents);
748
749 if (bfd_link_relocatable (info))
750 {
751 /* This is a relocatable link. We don't have to change
752 anything, unless the reloc is against a section symbol,
753 in which case we have to adjust according to where the
754 section symbol winds up in the output section. */
755 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
756 rel->r_addend += sec->output_offset;
757 continue;
758 }
759
760 switch (ELF32_R_TYPE (rel->r_info))
761 {
762 case R_RL78_DIR16S:
763 {
764 bfd_vma *plt_offset;
765
766 if (h != NULL)
767 plt_offset = &h->plt.offset;
768 else
769 plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
770
771 if (! valid_16bit_address (relocation))
772 {
773 /* If this is the first time we've processed this symbol,
774 fill in the plt entry with the correct symbol address. */
775 if ((*plt_offset & 1) == 0)
776 {
777 unsigned int x;
778
779 x = 0x000000ec; /* br !!abs24 */
780 x |= (relocation << 8) & 0xffffff00;
781 bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
782 *plt_offset |= 1;
783 }
784
785 relocation = (splt->output_section->vma
786 + splt->output_offset
787 + (*plt_offset & -2));
788 if (name)
789 {
790 char *newname = bfd_malloc (strlen(name)+5);
791 strcpy (newname, name);
792 strcat(newname, ".plt");
793 _bfd_generic_link_add_one_symbol (info,
794 input_bfd,
795 newname,
796 BSF_FUNCTION | BSF_WEAK,
797 splt,
798 (*plt_offset & -2),
799 0,
800 1,
801 0,
802 0);
803 }
804 }
805 }
806 break;
807 }
808
809 if (h != NULL && h->root.type == bfd_link_hash_undefweak)
810 /* If the symbol is undefined and weak
811 then the relocation resolves to zero. */
812 relocation = 0;
813 else
814 {
815 if (howto->pc_relative)
816 {
817 relocation -= (input_section->output_section->vma
818 + input_section->output_offset
819 + rel->r_offset);
820 relocation -= bfd_get_reloc_size (howto);
821 }
822
823 relocation += rel->r_addend;
824 }
825
826 r = bfd_reloc_ok;
827
828 #define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
829
830 /* Opcode relocs are always big endian. Data relocs are bi-endian. */
831 switch (r_type)
832 {
833 case R_RL78_NONE:
834 break;
835
836 case R_RL78_RH_RELAX:
837 break;
838
839 case R_RL78_DIR8S_PCREL:
840 RANGE (-128, 127);
841 OP (0) = relocation;
842 break;
843
844 case R_RL78_DIR8S:
845 RANGE (-128, 255);
846 OP (0) = relocation;
847 break;
848
849 case R_RL78_DIR8U:
850 RANGE (0, 255);
851 OP (0) = relocation;
852 break;
853
854 case R_RL78_DIR16S_PCREL:
855 RANGE (-32768, 32767);
856 OP (0) = relocation;
857 OP (1) = relocation >> 8;
858 break;
859
860 case R_RL78_DIR16S:
861 if ((relocation & 0xf0000) == 0xf0000)
862 relocation &= 0xffff;
863 RANGE (-32768, 65535);
864 OP (0) = relocation;
865 OP (1) = relocation >> 8;
866 break;
867
868 case R_RL78_DIR16U:
869 RANGE (0, 65536);
870 OP (0) = relocation;
871 OP (1) = relocation >> 8;
872 break;
873
874 case R_RL78_DIR16:
875 RANGE (-32768, 65536);
876 OP (0) = relocation;
877 OP (1) = relocation >> 8;
878 break;
879
880 case R_RL78_DIR16_REV:
881 RANGE (-32768, 65536);
882 OP (1) = relocation;
883 OP (0) = relocation >> 8;
884 break;
885
886 case R_RL78_DIR3U_PCREL:
887 RANGE (3, 10);
888 OP (0) &= 0xf8;
889 OP (0) |= relocation & 0x07;
890 break;
891
892 case R_RL78_DIR24S_PCREL:
893 RANGE (-0x800000, 0x7fffff);
894 OP (0) = relocation;
895 OP (1) = relocation >> 8;
896 OP (2) = relocation >> 16;
897 break;
898
899 case R_RL78_DIR24S:
900 RANGE (-0x800000, 0x7fffff);
901 OP (0) = relocation;
902 OP (1) = relocation >> 8;
903 OP (2) = relocation >> 16;
904 break;
905
906 case R_RL78_DIR32:
907 OP (0) = relocation;
908 OP (1) = relocation >> 8;
909 OP (2) = relocation >> 16;
910 OP (3) = relocation >> 24;
911 break;
912
913 case R_RL78_DIR32_REV:
914 OP (3) = relocation;
915 OP (2) = relocation >> 8;
916 OP (1) = relocation >> 16;
917 OP (0) = relocation >> 24;
918 break;
919
920 case R_RL78_RH_SFR:
921 RANGE (0xfff00, 0xfffff);
922 OP (0) = relocation & 0xff;
923 break;
924
925 case R_RL78_RH_SADDR:
926 RANGE (0xffe20, 0xfff1f);
927 OP (0) = relocation & 0xff;
928 break;
929
930 /* Complex reloc handling: */
931 case R_RL78_ABS32:
932 case R_RL78_ABS32_REV:
933 case R_RL78_ABS24S_PCREL:
934 case R_RL78_ABS24S:
935 case R_RL78_ABS16:
936 case R_RL78_ABS16_REV:
937 case R_RL78_ABS16S_PCREL:
938 case R_RL78_ABS16S:
939 case R_RL78_ABS16U:
940 case R_RL78_ABS16UL:
941 case R_RL78_ABS16UW:
942 case R_RL78_ABS8:
943 case R_RL78_ABS8U:
944 case R_RL78_ABS8UL:
945 case R_RL78_ABS8UW:
946 case R_RL78_ABS8S_PCREL:
947 case R_RL78_ABS8S:
948 case R_RL78_OPneg:
949 case R_RL78_OPadd:
950 case R_RL78_OPsub:
951 case R_RL78_OPmul:
952 case R_RL78_OPdiv:
953 case R_RL78_OPshla:
954 case R_RL78_OPshra:
955 case R_RL78_OPsctsize:
956 case R_RL78_OPscttop:
957 case R_RL78_OPand:
958 case R_RL78_OPor:
959 case R_RL78_OPxor:
960 case R_RL78_OPnot:
961 case R_RL78_OPmod:
962 relocation = rl78_compute_complex_reloc (r_type, 0, input_section);
963
964 switch (r_type)
965 {
966 case R_RL78_ABS32:
967 OP (0) = relocation;
968 OP (1) = relocation >> 8;
969 OP (2) = relocation >> 16;
970 OP (3) = relocation >> 24;
971 break;
972
973 case R_RL78_ABS32_REV:
974 OP (3) = relocation;
975 OP (2) = relocation >> 8;
976 OP (1) = relocation >> 16;
977 OP (0) = relocation >> 24;
978 break;
979
980 case R_RL78_ABS24S_PCREL:
981 case R_RL78_ABS24S:
982 RANGE (-0x800000, 0x7fffff);
983 OP (0) = relocation;
984 OP (1) = relocation >> 8;
985 OP (2) = relocation >> 16;
986 break;
987
988 case R_RL78_ABS16:
989 RANGE (-32768, 65535);
990 OP (0) = relocation;
991 OP (1) = relocation >> 8;
992 break;
993
994 case R_RL78_ABS16_REV:
995 RANGE (-32768, 65535);
996 OP (1) = relocation;
997 OP (0) = relocation >> 8;
998 break;
999
1000 case R_RL78_ABS16S_PCREL:
1001 case R_RL78_ABS16S:
1002 RANGE (-32768, 32767);
1003 OP (0) = relocation;
1004 OP (1) = relocation >> 8;
1005 break;
1006
1007 case R_RL78_ABS16U:
1008 case R_RL78_ABS16UL:
1009 case R_RL78_ABS16UW:
1010 RANGE (0, 65536);
1011 OP (0) = relocation;
1012 OP (1) = relocation >> 8;
1013 break;
1014
1015 case R_RL78_ABS8:
1016 RANGE (-128, 255);
1017 OP (0) = relocation;
1018 break;
1019
1020 case R_RL78_ABS8U:
1021 case R_RL78_ABS8UL:
1022 case R_RL78_ABS8UW:
1023 RANGE (0, 255);
1024 OP (0) = relocation;
1025 break;
1026
1027 case R_RL78_ABS8S_PCREL:
1028 case R_RL78_ABS8S:
1029 RANGE (-128, 127);
1030 OP (0) = relocation;
1031 break;
1032
1033 default:
1034 break;
1035 }
1036 break;
1037
1038 case R_RL78_SYM:
1039 if (r_symndx < symtab_hdr->sh_info)
1040 relocation = sec->output_section->vma + sec->output_offset
1041 + sym->st_value + rel->r_addend;
1042 else if (h != NULL
1043 && (h->root.type == bfd_link_hash_defined
1044 || h->root.type == bfd_link_hash_defweak))
1045 relocation = h->root.u.def.value
1046 + sec->output_section->vma
1047 + sec->output_offset
1048 + rel->r_addend;
1049 else
1050 {
1051 relocation = 0;
1052 if (h->root.type != bfd_link_hash_undefweak)
1053 _bfd_error_handler
1054 (_("warning: RL78_SYM reloc with an unknown symbol"));
1055 }
1056 (void) rl78_compute_complex_reloc (r_type, relocation, input_section);
1057 break;
1058
1059 case R_RL78_OPromtop:
1060 relocation = get_romstart (info, input_bfd, input_section, rel->r_offset);
1061 (void) rl78_compute_complex_reloc (r_type, relocation, input_section);
1062 break;
1063
1064 case R_RL78_OPramtop:
1065 relocation = get_ramstart (info, input_bfd, input_section, rel->r_offset);
1066 (void) rl78_compute_complex_reloc (r_type, relocation, input_section);
1067 break;
1068
1069 default:
1070 r = bfd_reloc_notsupported;
1071 break;
1072 }
1073
1074 if (r != bfd_reloc_ok)
1075 {
1076 const char * msg = NULL;
1077
1078 switch (r)
1079 {
1080 case bfd_reloc_overflow:
1081 /* Catch the case of a missing function declaration
1082 and emit a more helpful error message. */
1083 if (r_type == R_RL78_DIR24S_PCREL)
1084 /* xgettext:c-format */
1085 msg = _("%pB(%pA): error: call to undefined function '%s'");
1086 else
1087 (*info->callbacks->reloc_overflow)
1088 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
1089 input_bfd, input_section, rel->r_offset);
1090 break;
1091
1092 case bfd_reloc_undefined:
1093 (*info->callbacks->undefined_symbol)
1094 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1095 break;
1096
1097 case bfd_reloc_other:
1098 /* xgettext:c-format */
1099 msg = _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
1100 break;
1101
1102 case bfd_reloc_outofrange:
1103 /* xgettext:c-format */
1104 msg = _("%pB(%pA): internal error: out of range error");
1105 break;
1106
1107 case bfd_reloc_notsupported:
1108 /* xgettext:c-format */
1109 msg = _("%pB(%pA): internal error: unsupported relocation error");
1110 break;
1111
1112 case bfd_reloc_dangerous:
1113 /* xgettext:c-format */
1114 msg = _("%pB(%pA): internal error: dangerous relocation");
1115 break;
1116
1117 default:
1118 /* xgettext:c-format */
1119 msg = _("%pB(%pA): internal error: unknown error");
1120 break;
1121 }
1122
1123 if (msg)
1124 _bfd_error_handler (msg, input_bfd, input_section, name);
1125 }
1126 }
1127
1128 return TRUE;
1129 }
1130 \f
1131 /* Function to set the ELF flag bits. */
1132
1133 static bfd_boolean
1134 rl78_elf_set_private_flags (bfd * abfd, flagword flags)
1135 {
1136 elf_elfheader (abfd)->e_flags = flags;
1137 elf_flags_init (abfd) = TRUE;
1138 return TRUE;
1139 }
1140
1141 static bfd_boolean no_warn_mismatch = FALSE;
1142
1143 void bfd_elf32_rl78_set_target_flags (bfd_boolean);
1144
1145 void
1146 bfd_elf32_rl78_set_target_flags (bfd_boolean user_no_warn_mismatch)
1147 {
1148 no_warn_mismatch = user_no_warn_mismatch;
1149 }
1150
1151 static const char *
1152 rl78_cpu_name (flagword flags)
1153 {
1154 switch (flags & E_FLAG_RL78_CPU_MASK)
1155 {
1156 default: return "";
1157 case E_FLAG_RL78_G10: return "G10";
1158 case E_FLAG_RL78_G13: return "G13";
1159 case E_FLAG_RL78_G14: return "G14";
1160 }
1161 }
1162
1163 /* Merge backend specific data from an object file to the output
1164 object file when linking. */
1165
1166 static bfd_boolean
1167 rl78_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
1168 {
1169 bfd *obfd = info->output_bfd;
1170 flagword new_flags;
1171 flagword old_flags;
1172 bfd_boolean error = FALSE;
1173
1174 new_flags = elf_elfheader (ibfd)->e_flags;
1175 old_flags = elf_elfheader (obfd)->e_flags;
1176
1177 if (!elf_flags_init (obfd))
1178 {
1179 /* First call, no flags set. */
1180 elf_flags_init (obfd) = TRUE;
1181 elf_elfheader (obfd)->e_flags = new_flags;
1182 }
1183 else if (old_flags != new_flags)
1184 {
1185 flagword changed_flags = old_flags ^ new_flags;
1186
1187 if (changed_flags & E_FLAG_RL78_CPU_MASK)
1188 {
1189 flagword out_cpu = old_flags & E_FLAG_RL78_CPU_MASK;
1190 flagword in_cpu = new_flags & E_FLAG_RL78_CPU_MASK;
1191
1192 if (in_cpu == E_FLAG_RL78_ANY_CPU || in_cpu == out_cpu)
1193 /* It does not matter what new_cpu may have. */;
1194 else if (out_cpu == E_FLAG_RL78_ANY_CPU)
1195 {
1196 if (in_cpu == E_FLAG_RL78_G10)
1197 {
1198 /* G10 files can only be linked with other G10 files.
1199 If the output is set to "any" this means that it is
1200 a G14 file that does not use hardware multiply/divide,
1201 but that is still incompatible with the G10 ABI. */
1202 error = TRUE;
1203
1204 _bfd_error_handler
1205 /* xgettext:c-format */
1206 (_("RL78 ABI conflict: G10 file %pB cannot be linked"
1207 " with %s file %pB"),
1208 ibfd, rl78_cpu_name (out_cpu), obfd);
1209 }
1210 else
1211 {
1212 old_flags &= ~ E_FLAG_RL78_CPU_MASK;
1213 old_flags |= in_cpu;
1214 elf_elfheader (obfd)->e_flags = old_flags;
1215 }
1216 }
1217 else
1218 {
1219 error = TRUE;
1220
1221 _bfd_error_handler
1222 /* xgettext:c-format */
1223 (_("RL78 ABI conflict: cannot link %s file %pB with %s file %pB"),
1224 rl78_cpu_name (in_cpu), ibfd,
1225 rl78_cpu_name (out_cpu), obfd);
1226 }
1227 }
1228
1229 if (changed_flags & E_FLAG_RL78_64BIT_DOUBLES)
1230 {
1231 _bfd_error_handler
1232 (_("RL78 merge conflict: cannot link 32-bit and 64-bit objects together"));
1233
1234 if (old_flags & E_FLAG_RL78_64BIT_DOUBLES)
1235 /* xgettext:c-format */
1236 _bfd_error_handler (_("- %pB is 64-bit, %pB is not"),
1237 obfd, ibfd);
1238 else
1239 /* xgettext:c-format */
1240 _bfd_error_handler (_("- %pB is 64-bit, %pB is not"),
1241 ibfd, obfd);
1242 error = TRUE;
1243 }
1244 }
1245
1246 return !error;
1247 }
1248 \f
1249 static bfd_boolean
1250 rl78_elf_print_private_bfd_data (bfd * abfd, void * ptr)
1251 {
1252 FILE * file = (FILE *) ptr;
1253 flagword flags;
1254
1255 BFD_ASSERT (abfd != NULL && ptr != NULL);
1256
1257 /* Print normal ELF private data. */
1258 _bfd_elf_print_private_bfd_data (abfd, ptr);
1259
1260 flags = elf_elfheader (abfd)->e_flags;
1261 fprintf (file, _("private flags = 0x%lx:"), (long) flags);
1262
1263 if (flags & E_FLAG_RL78_CPU_MASK)
1264 fprintf (file, " [%s]", rl78_cpu_name (flags));
1265
1266 if (flags & E_FLAG_RL78_64BIT_DOUBLES)
1267 fprintf (file, _(" [64-bit doubles]"));
1268
1269 fputc ('\n', file);
1270 return TRUE;
1271 }
1272
1273 /* Return the MACH for an e_flags value. */
1274
1275 static int
1276 elf32_rl78_machine (bfd * abfd ATTRIBUTE_UNUSED)
1277 {
1278 return bfd_mach_rl78;
1279 }
1280
1281 static bfd_boolean
1282 rl78_elf_object_p (bfd * abfd)
1283 {
1284 bfd_default_set_arch_mach (abfd, bfd_arch_rl78,
1285 elf32_rl78_machine (abfd));
1286 return TRUE;
1287 }
1288 \f
1289 /* support PLT for 16-bit references to 24-bit functions. */
1290
1291 /* We support 16-bit pointers to code above 64k by generating a thunk
1292 below 64k containing a JMP instruction to the final address. */
1293
1294 static bfd_boolean
1295 rl78_elf_check_relocs
1296 (bfd * abfd,
1297 struct bfd_link_info * info,
1298 asection * sec,
1299 const Elf_Internal_Rela * relocs)
1300 {
1301 Elf_Internal_Shdr * symtab_hdr;
1302 struct elf_link_hash_entry ** sym_hashes;
1303 const Elf_Internal_Rela * rel;
1304 const Elf_Internal_Rela * rel_end;
1305 bfd_vma *local_plt_offsets;
1306 asection *splt;
1307 bfd *dynobj;
1308
1309 if (bfd_link_relocatable (info))
1310 return TRUE;
1311
1312 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1313 sym_hashes = elf_sym_hashes (abfd);
1314 local_plt_offsets = elf_local_got_offsets (abfd);
1315 dynobj = elf_hash_table(info)->dynobj;
1316
1317 rel_end = relocs + sec->reloc_count;
1318 for (rel = relocs; rel < rel_end; rel++)
1319 {
1320 struct elf_link_hash_entry *h;
1321 unsigned long r_symndx;
1322 bfd_vma *offset;
1323
1324 r_symndx = ELF32_R_SYM (rel->r_info);
1325 if (r_symndx < symtab_hdr->sh_info)
1326 h = NULL;
1327 else
1328 {
1329 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1330 while (h->root.type == bfd_link_hash_indirect
1331 || h->root.type == bfd_link_hash_warning)
1332 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1333 }
1334
1335 switch (ELF32_R_TYPE (rel->r_info))
1336 {
1337 /* This relocation describes a 16-bit pointer to a function.
1338 We may need to allocate a thunk in low memory; reserve memory
1339 for it now. */
1340 case R_RL78_DIR16S:
1341 if (dynobj == NULL)
1342 elf_hash_table (info)->dynobj = dynobj = abfd;
1343 splt = elf_hash_table (info)->splt;
1344 if (splt == NULL)
1345 {
1346 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1347 | SEC_IN_MEMORY | SEC_LINKER_CREATED
1348 | SEC_READONLY | SEC_CODE);
1349 splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
1350 flags);
1351 elf_hash_table (info)->splt = splt;
1352 if (splt == NULL
1353 || ! bfd_set_section_alignment (dynobj, splt, 1))
1354 return FALSE;
1355 }
1356
1357 if (h != NULL)
1358 offset = &h->plt.offset;
1359 else
1360 {
1361 if (local_plt_offsets == NULL)
1362 {
1363 size_t size;
1364 unsigned int i;
1365
1366 size = symtab_hdr->sh_info * sizeof (bfd_vma);
1367 local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1368 if (local_plt_offsets == NULL)
1369 return FALSE;
1370 elf_local_got_offsets (abfd) = local_plt_offsets;
1371
1372 for (i = 0; i < symtab_hdr->sh_info; i++)
1373 local_plt_offsets[i] = (bfd_vma) -1;
1374 }
1375 offset = &local_plt_offsets[r_symndx];
1376 }
1377
1378 if (*offset == (bfd_vma) -1)
1379 {
1380 *offset = splt->size;
1381 splt->size += 4;
1382 }
1383 break;
1384 }
1385 }
1386
1387 return TRUE;
1388 }
1389
1390 /* This must exist if dynobj is ever set. */
1391
1392 static bfd_boolean
1393 rl78_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
1394 struct bfd_link_info *info)
1395 {
1396 bfd *dynobj;
1397 asection *splt;
1398
1399 if (!elf_hash_table (info)->dynamic_sections_created)
1400 return TRUE;
1401
1402 /* As an extra sanity check, verify that all plt entries have been
1403 filled in. However, relaxing might have changed the relocs so
1404 that some plt entries don't get filled in, so we have to skip
1405 this check if we're relaxing. Unfortunately, check_relocs is
1406 called before relaxation. */
1407
1408 if (info->relax_trip > 0)
1409 return TRUE;
1410
1411 dynobj = elf_hash_table (info)->dynobj;
1412 splt = elf_hash_table (info)->splt;
1413 if (dynobj != NULL && splt != NULL)
1414 {
1415 bfd_byte *contents = splt->contents;
1416 unsigned int i, size = splt->size;
1417
1418 for (i = 0; i < size; i += 4)
1419 {
1420 unsigned int x = bfd_get_32 (dynobj, contents + i);
1421 BFD_ASSERT (x != 0);
1422 }
1423 }
1424
1425 return TRUE;
1426 }
1427
1428 static bfd_boolean
1429 rl78_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1430 struct bfd_link_info *info)
1431 {
1432 bfd *dynobj;
1433 asection *splt;
1434
1435 if (bfd_link_relocatable (info))
1436 return TRUE;
1437
1438 dynobj = elf_hash_table (info)->dynobj;
1439 if (dynobj == NULL)
1440 return TRUE;
1441
1442 splt = elf_hash_table (info)->splt;
1443 BFD_ASSERT (splt != NULL);
1444
1445 splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
1446 if (splt->contents == NULL)
1447 return FALSE;
1448
1449 return TRUE;
1450 }
1451
1452 \f
1453
1454 /* Handle relaxing. */
1455
1456 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1457 is within the low 64k, remove any entry for it in the plt. */
1458
1459 struct relax_plt_data
1460 {
1461 asection *splt;
1462 bfd_boolean *again;
1463 };
1464
1465 static bfd_boolean
1466 rl78_relax_plt_check (struct elf_link_hash_entry *h, void * xdata)
1467 {
1468 struct relax_plt_data *data = (struct relax_plt_data *) xdata;
1469
1470 if (h->plt.offset != (bfd_vma) -1)
1471 {
1472 bfd_vma address;
1473
1474 if (h->root.type == bfd_link_hash_undefined
1475 || h->root.type == bfd_link_hash_undefweak)
1476 address = 0;
1477 else
1478 address = (h->root.u.def.section->output_section->vma
1479 + h->root.u.def.section->output_offset
1480 + h->root.u.def.value);
1481
1482 if (valid_16bit_address (address))
1483 {
1484 h->plt.offset = -1;
1485 data->splt->size -= 4;
1486 *data->again = TRUE;
1487 }
1488 }
1489
1490 return TRUE;
1491 }
1492
1493 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1494 previously had a plt entry, give it a new entry offset. */
1495
1496 static bfd_boolean
1497 rl78_relax_plt_realloc (struct elf_link_hash_entry *h, void * xdata)
1498 {
1499 bfd_vma *entry = (bfd_vma *) xdata;
1500
1501 if (h->plt.offset != (bfd_vma) -1)
1502 {
1503 h->plt.offset = *entry;
1504 *entry += 4;
1505 }
1506
1507 return TRUE;
1508 }
1509
1510 static bfd_boolean
1511 rl78_elf_relax_plt_section (bfd *dynobj,
1512 asection *splt,
1513 struct bfd_link_info *info,
1514 bfd_boolean *again)
1515 {
1516 struct relax_plt_data relax_plt_data;
1517 bfd *ibfd;
1518
1519 /* Assume nothing changes. */
1520 *again = FALSE;
1521
1522 if (bfd_link_relocatable (info))
1523 return TRUE;
1524
1525 /* We only relax the .plt section at the moment. */
1526 if (dynobj != elf_hash_table (info)->dynobj
1527 || strcmp (splt->name, ".plt") != 0)
1528 return TRUE;
1529
1530 /* Quick check for an empty plt. */
1531 if (splt->size == 0)
1532 return TRUE;
1533
1534 /* Map across all global symbols; see which ones happen to
1535 fall in the low 64k. */
1536 relax_plt_data.splt = splt;
1537 relax_plt_data.again = again;
1538 elf_link_hash_traverse (elf_hash_table (info), rl78_relax_plt_check,
1539 &relax_plt_data);
1540
1541 /* Likewise for local symbols, though that's somewhat less convenient
1542 as we have to walk the list of input bfds and swap in symbol data. */
1543 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
1544 {
1545 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1546 Elf_Internal_Shdr *symtab_hdr;
1547 Elf_Internal_Sym *isymbuf = NULL;
1548 unsigned int idx;
1549
1550 if (! local_plt_offsets)
1551 continue;
1552
1553 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1554 if (symtab_hdr->sh_info != 0)
1555 {
1556 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1557 if (isymbuf == NULL)
1558 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1559 symtab_hdr->sh_info, 0,
1560 NULL, NULL, NULL);
1561 if (isymbuf == NULL)
1562 return FALSE;
1563 }
1564
1565 for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1566 {
1567 Elf_Internal_Sym *isym;
1568 asection *tsec;
1569 bfd_vma address;
1570
1571 if (local_plt_offsets[idx] == (bfd_vma) -1)
1572 continue;
1573
1574 isym = &isymbuf[idx];
1575 if (isym->st_shndx == SHN_UNDEF)
1576 continue;
1577 else if (isym->st_shndx == SHN_ABS)
1578 tsec = bfd_abs_section_ptr;
1579 else if (isym->st_shndx == SHN_COMMON)
1580 tsec = bfd_com_section_ptr;
1581 else
1582 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1583
1584 address = (tsec->output_section->vma
1585 + tsec->output_offset
1586 + isym->st_value);
1587 if (valid_16bit_address (address))
1588 {
1589 local_plt_offsets[idx] = -1;
1590 splt->size -= 4;
1591 *again = TRUE;
1592 }
1593 }
1594
1595 if (isymbuf != NULL
1596 && symtab_hdr->contents != (unsigned char *) isymbuf)
1597 {
1598 if (! info->keep_memory)
1599 free (isymbuf);
1600 else
1601 {
1602 /* Cache the symbols for elf_link_input_bfd. */
1603 symtab_hdr->contents = (unsigned char *) isymbuf;
1604 }
1605 }
1606 }
1607
1608 /* If we changed anything, walk the symbols again to reallocate
1609 .plt entry addresses. */
1610 if (*again && splt->size > 0)
1611 {
1612 bfd_vma entry = 0;
1613
1614 elf_link_hash_traverse (elf_hash_table (info),
1615 rl78_relax_plt_realloc, &entry);
1616
1617 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
1618 {
1619 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1620 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1621 unsigned int idx;
1622
1623 if (! local_plt_offsets)
1624 continue;
1625
1626 for (idx = 0; idx < nlocals; ++idx)
1627 if (local_plt_offsets[idx] != (bfd_vma) -1)
1628 {
1629 local_plt_offsets[idx] = entry;
1630 entry += 4;
1631 }
1632 }
1633 }
1634
1635 return TRUE;
1636 }
1637
1638 /* Delete some bytes from a section while relaxing. */
1639
1640 static bfd_boolean
1641 elf32_rl78_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count,
1642 Elf_Internal_Rela *alignment_rel, int force_snip)
1643 {
1644 Elf_Internal_Shdr * symtab_hdr;
1645 unsigned int sec_shndx;
1646 bfd_byte * contents;
1647 Elf_Internal_Rela * irel;
1648 Elf_Internal_Rela * irelend;
1649 Elf_Internal_Sym * isym;
1650 Elf_Internal_Sym * isymend;
1651 bfd_vma toaddr;
1652 unsigned int symcount;
1653 struct elf_link_hash_entry ** sym_hashes;
1654 struct elf_link_hash_entry ** end_hashes;
1655
1656 if (!alignment_rel)
1657 force_snip = 1;
1658
1659 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1660
1661 contents = elf_section_data (sec)->this_hdr.contents;
1662
1663 /* The deletion must stop at the next alignment boundary, if
1664 ALIGNMENT_REL is non-NULL. */
1665 toaddr = sec->size;
1666 if (alignment_rel)
1667 toaddr = alignment_rel->r_offset;
1668
1669 irel = elf_section_data (sec)->relocs;
1670 if (irel == NULL)
1671 {
1672 _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
1673 irel = elf_section_data (sec)->relocs;
1674 }
1675
1676 irelend = irel + sec->reloc_count;
1677
1678 /* Actually delete the bytes. */
1679 memmove (contents + addr, contents + addr + count,
1680 (size_t) (toaddr - addr - count));
1681
1682 /* If we don't have an alignment marker to worry about, we can just
1683 shrink the section. Otherwise, we have to fill in the newly
1684 created gap with NOP insns (0x03). */
1685 if (force_snip)
1686 sec->size -= count;
1687 else
1688 memset (contents + toaddr - count, 0x03, count);
1689
1690 /* Adjust all the relocs. */
1691 for (; irel && irel < irelend; irel++)
1692 {
1693 /* Get the new reloc address. */
1694 if (irel->r_offset > addr
1695 && (irel->r_offset < toaddr
1696 || (force_snip && irel->r_offset == toaddr)))
1697 irel->r_offset -= count;
1698
1699 /* If we see an ALIGN marker at the end of the gap, we move it
1700 to the beginning of the gap, since marking these gaps is what
1701 they're for. */
1702 if (irel->r_offset == toaddr
1703 && ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
1704 && irel->r_addend & RL78_RELAXA_ALIGN)
1705 irel->r_offset -= count;
1706 }
1707
1708 /* Adjust the local symbols defined in this section. */
1709 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1710 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1711 isymend = isym + symtab_hdr->sh_info;
1712
1713 for (; isym < isymend; isym++)
1714 {
1715 /* If the symbol is in the range of memory we just moved, we
1716 have to adjust its value. */
1717 if (isym->st_shndx == sec_shndx
1718 && isym->st_value > addr
1719 && isym->st_value < toaddr)
1720 isym->st_value -= count;
1721
1722 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1723 *end* is in the moved bytes but it's *start* isn't), then we
1724 must adjust its size. */
1725 if (isym->st_shndx == sec_shndx
1726 && isym->st_value < addr
1727 && isym->st_value + isym->st_size > addr
1728 && isym->st_value + isym->st_size < toaddr)
1729 isym->st_size -= count;
1730 }
1731
1732 /* Now adjust the global symbols defined in this section. */
1733 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1734 - symtab_hdr->sh_info);
1735 sym_hashes = elf_sym_hashes (abfd);
1736 end_hashes = sym_hashes + symcount;
1737
1738 for (; sym_hashes < end_hashes; sym_hashes++)
1739 {
1740 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1741
1742 if ((sym_hash->root.type == bfd_link_hash_defined
1743 || sym_hash->root.type == bfd_link_hash_defweak)
1744 && sym_hash->root.u.def.section == sec)
1745 {
1746 /* As above, adjust the value if needed. */
1747 if (sym_hash->root.u.def.value > addr
1748 && sym_hash->root.u.def.value < toaddr)
1749 sym_hash->root.u.def.value -= count;
1750
1751 /* As above, adjust the size if needed. */
1752 if (sym_hash->root.u.def.value < addr
1753 && sym_hash->root.u.def.value + sym_hash->size > addr
1754 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1755 sym_hash->size -= count;
1756 }
1757 }
1758
1759 return TRUE;
1760 }
1761
1762 /* Used to sort relocs by address. If relocs have the same address,
1763 we maintain their relative order, except that R_RL78_RH_RELAX
1764 alignment relocs must be the first reloc for any given address. */
1765
1766 static void
1767 reloc_bubblesort (Elf_Internal_Rela * r, int count)
1768 {
1769 int i;
1770 bfd_boolean again;
1771 bfd_boolean swappit;
1772
1773 /* This is almost a classic bubblesort. It's the slowest sort, but
1774 we're taking advantage of the fact that the relocations are
1775 mostly in order already (the assembler emits them that way) and
1776 we need relocs with the same address to remain in the same
1777 relative order. */
1778 again = TRUE;
1779 while (again)
1780 {
1781 again = FALSE;
1782 for (i = 0; i < count - 1; i ++)
1783 {
1784 if (r[i].r_offset > r[i + 1].r_offset)
1785 swappit = TRUE;
1786 else if (r[i].r_offset < r[i + 1].r_offset)
1787 swappit = FALSE;
1788 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1789 && (r[i + 1].r_addend & RL78_RELAXA_ALIGN))
1790 swappit = TRUE;
1791 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1792 && (r[i + 1].r_addend & RL78_RELAXA_ELIGN)
1793 && !(ELF32_R_TYPE (r[i].r_info) == R_RL78_RH_RELAX
1794 && (r[i].r_addend & RL78_RELAXA_ALIGN)))
1795 swappit = TRUE;
1796 else
1797 swappit = FALSE;
1798
1799 if (swappit)
1800 {
1801 Elf_Internal_Rela tmp;
1802
1803 tmp = r[i];
1804 r[i] = r[i + 1];
1805 r[i + 1] = tmp;
1806 /* If we do move a reloc back, re-scan to see if it
1807 needs to be moved even further back. This avoids
1808 most of the O(n^2) behavior for our cases. */
1809 if (i > 0)
1810 i -= 2;
1811 again = TRUE;
1812 }
1813 }
1814 }
1815 }
1816
1817
1818 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1819 rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1820 lrel, abfd, sec, link_info, scale)
1821
1822 static bfd_vma
1823 rl78_offset_for_reloc (bfd * abfd,
1824 Elf_Internal_Rela * rel,
1825 Elf_Internal_Shdr * symtab_hdr,
1826 Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
1827 Elf_Internal_Sym * intsyms,
1828 Elf_Internal_Rela ** lrel,
1829 bfd * input_bfd,
1830 asection * input_section,
1831 struct bfd_link_info * info,
1832 int * scale)
1833 {
1834 bfd_vma symval;
1835
1836 *scale = 1;
1837
1838 /* REL is the first of 1..N relocations. We compute the symbol
1839 value for each relocation, then combine them if needed. LREL
1840 gets a pointer to the last relocation used. */
1841 while (1)
1842 {
1843 unsigned long r_type;
1844
1845 /* Get the value of the symbol referred to by the reloc. */
1846 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1847 {
1848 /* A local symbol. */
1849 Elf_Internal_Sym *isym;
1850 asection *ssec;
1851
1852 isym = intsyms + ELF32_R_SYM (rel->r_info);
1853
1854 if (isym->st_shndx == SHN_UNDEF)
1855 ssec = bfd_und_section_ptr;
1856 else if (isym->st_shndx == SHN_ABS)
1857 ssec = bfd_abs_section_ptr;
1858 else if (isym->st_shndx == SHN_COMMON)
1859 ssec = bfd_com_section_ptr;
1860 else
1861 ssec = bfd_section_from_elf_index (abfd,
1862 isym->st_shndx);
1863
1864 /* Initial symbol value. */
1865 symval = isym->st_value;
1866
1867 /* GAS may have made this symbol relative to a section, in
1868 which case, we have to add the addend to find the
1869 symbol. */
1870 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
1871 symval += rel->r_addend;
1872
1873 if (ssec)
1874 {
1875 if ((ssec->flags & SEC_MERGE)
1876 && ssec->sec_info_type == SEC_INFO_TYPE_MERGE)
1877 symval = _bfd_merged_section_offset (abfd, & ssec,
1878 elf_section_data (ssec)->sec_info,
1879 symval);
1880 }
1881
1882 /* Now make the offset relative to where the linker is putting it. */
1883 if (ssec)
1884 symval +=
1885 ssec->output_section->vma + ssec->output_offset;
1886
1887 symval += rel->r_addend;
1888 }
1889 else
1890 {
1891 unsigned long indx;
1892 struct elf_link_hash_entry * h;
1893
1894 /* An external symbol. */
1895 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1896 h = elf_sym_hashes (abfd)[indx];
1897 BFD_ASSERT (h != NULL);
1898
1899 if (h->root.type != bfd_link_hash_defined
1900 && h->root.type != bfd_link_hash_defweak)
1901 {
1902 /* This appears to be a reference to an undefined
1903 symbol. Just ignore it--it will be caught by the
1904 regular reloc processing. */
1905 if (lrel)
1906 *lrel = rel;
1907 return 0;
1908 }
1909
1910 symval = (h->root.u.def.value
1911 + h->root.u.def.section->output_section->vma
1912 + h->root.u.def.section->output_offset);
1913
1914 symval += rel->r_addend;
1915 }
1916
1917 r_type = ELF32_R_TYPE (rel->r_info);
1918 switch (r_type)
1919 {
1920 case R_RL78_SYM:
1921 (void) rl78_compute_complex_reloc (r_type, symval, input_section);
1922 break;
1923
1924 case R_RL78_OPromtop:
1925 symval = get_romstart (info, input_bfd, input_section, rel->r_offset);
1926 (void) rl78_compute_complex_reloc (r_type, symval, input_section);
1927 break;
1928
1929 case R_RL78_OPramtop:
1930 symval = get_ramstart (info, input_bfd, input_section, rel->r_offset);
1931 (void) rl78_compute_complex_reloc (r_type, symval, input_section);
1932 break;
1933
1934 case R_RL78_OPneg:
1935 case R_RL78_OPadd:
1936 case R_RL78_OPsub:
1937 case R_RL78_OPmul:
1938 case R_RL78_OPdiv:
1939 case R_RL78_OPshla:
1940 case R_RL78_OPshra:
1941 case R_RL78_OPsctsize:
1942 case R_RL78_OPscttop:
1943 case R_RL78_OPand:
1944 case R_RL78_OPor:
1945 case R_RL78_OPxor:
1946 case R_RL78_OPnot:
1947 case R_RL78_OPmod:
1948 (void) rl78_compute_complex_reloc (r_type, 0, input_section);
1949 break;
1950
1951 case R_RL78_DIR16UL:
1952 case R_RL78_DIR8UL:
1953 case R_RL78_ABS16UL:
1954 case R_RL78_ABS8UL:
1955 *scale = 4;
1956 goto reloc_computes_value;
1957
1958 case R_RL78_DIR16UW:
1959 case R_RL78_DIR8UW:
1960 case R_RL78_ABS16UW:
1961 case R_RL78_ABS8UW:
1962 *scale = 2;
1963 goto reloc_computes_value;
1964
1965 default:
1966 reloc_computes_value:
1967 symval = rl78_compute_complex_reloc (r_type, symval, input_section);
1968 /* Fall through. */
1969 case R_RL78_DIR32:
1970 case R_RL78_DIR24S:
1971 case R_RL78_DIR16:
1972 case R_RL78_DIR16U:
1973 case R_RL78_DIR16S:
1974 case R_RL78_DIR24S_PCREL:
1975 case R_RL78_DIR16S_PCREL:
1976 case R_RL78_DIR8S_PCREL:
1977 if (lrel)
1978 *lrel = rel;
1979 return symval;
1980 }
1981
1982 rel ++;
1983 }
1984 }
1985
1986 struct {
1987 int prefix; /* or -1 for "no prefix" */
1988 int insn; /* or -1 for "end of list" */
1989 int insn_for_saddr; /* or -1 for "no alternative" */
1990 int insn_for_sfr; /* or -1 for "no alternative" */
1991 } relax_addr16[] = {
1992 { -1, 0x02, 0x06, -1 }, /* ADDW AX, !addr16 */
1993 { -1, 0x22, 0x26, -1 }, /* SUBW AX, !addr16 */
1994 { -1, 0x42, 0x46, -1 }, /* CMPW AX, !addr16 */
1995 { -1, 0x40, 0x4a, -1 }, /* CMP !addr16, #byte */
1996
1997 { -1, 0x0f, 0x0b, -1 }, /* ADD A, !addr16 */
1998 { -1, 0x1f, 0x1b, -1 }, /* ADDC A, !addr16 */
1999 { -1, 0x2f, 0x2b, -1 }, /* SUB A, !addr16 */
2000 { -1, 0x3f, 0x3b, -1 }, /* SUBC A, !addr16 */
2001 { -1, 0x4f, 0x4b, -1 }, /* CMP A, !addr16 */
2002 { -1, 0x5f, 0x5b, -1 }, /* AND A, !addr16 */
2003 { -1, 0x6f, 0x6b, -1 }, /* OR A, !addr16 */
2004 { -1, 0x7f, 0x7b, -1 }, /* XOR A, !addr16 */
2005
2006 { -1, 0x8f, 0x8d, 0x8e }, /* MOV A, !addr16 */
2007 { -1, 0x9f, 0x9d, 0x9e }, /* MOV !addr16, A */
2008 { -1, 0xaf, 0xad, 0xae }, /* MOVW AX, !addr16 */
2009 { -1, 0xbf, 0xbd, 0xbe }, /* MOVW !addr16, AX */
2010 { -1, 0xcf, 0xcd, 0xce }, /* MOVW !addr16, #word */
2011
2012 { -1, 0xa0, 0xa4, -1 }, /* INC !addr16 */
2013 { -1, 0xa2, 0xa6, -1 }, /* INCW !addr16 */
2014 { -1, 0xb0, 0xb4, -1 }, /* DEC !addr16 */
2015 { -1, 0xb2, 0xb6, -1 }, /* DECW !addr16 */
2016
2017 { -1, 0xd5, 0xd4, -1 }, /* CMP0 !addr16 */
2018 { -1, 0xe5, 0xe4, -1 }, /* ONEB !addr16 */
2019 { -1, 0xf5, 0xf4, -1 }, /* CLRB !addr16 */
2020
2021 { -1, 0xd9, 0xd8, -1 }, /* MOV X, !addr16 */
2022 { -1, 0xe9, 0xe8, -1 }, /* MOV B, !addr16 */
2023 { -1, 0xf9, 0xf8, -1 }, /* MOV C, !addr16 */
2024 { -1, 0xdb, 0xda, -1 }, /* MOVW BC, !addr16 */
2025 { -1, 0xeb, 0xea, -1 }, /* MOVW DE, !addr16 */
2026 { -1, 0xfb, 0xfa, -1 }, /* MOVW HL, !addr16 */
2027
2028 { 0x61, 0xaa, 0xa8, -1 }, /* XCH A, !addr16 */
2029
2030 { 0x71, 0x00, 0x02, 0x0a }, /* SET1 !addr16.0 */
2031 { 0x71, 0x10, 0x12, 0x1a }, /* SET1 !addr16.0 */
2032 { 0x71, 0x20, 0x22, 0x2a }, /* SET1 !addr16.0 */
2033 { 0x71, 0x30, 0x32, 0x3a }, /* SET1 !addr16.0 */
2034 { 0x71, 0x40, 0x42, 0x4a }, /* SET1 !addr16.0 */
2035 { 0x71, 0x50, 0x52, 0x5a }, /* SET1 !addr16.0 */
2036 { 0x71, 0x60, 0x62, 0x6a }, /* SET1 !addr16.0 */
2037 { 0x71, 0x70, 0x72, 0x7a }, /* SET1 !addr16.0 */
2038
2039 { 0x71, 0x08, 0x03, 0x0b }, /* CLR1 !addr16.0 */
2040 { 0x71, 0x18, 0x13, 0x1b }, /* CLR1 !addr16.0 */
2041 { 0x71, 0x28, 0x23, 0x2b }, /* CLR1 !addr16.0 */
2042 { 0x71, 0x38, 0x33, 0x3b }, /* CLR1 !addr16.0 */
2043 { 0x71, 0x48, 0x43, 0x4b }, /* CLR1 !addr16.0 */
2044 { 0x71, 0x58, 0x53, 0x5b }, /* CLR1 !addr16.0 */
2045 { 0x71, 0x68, 0x63, 0x6b }, /* CLR1 !addr16.0 */
2046 { 0x71, 0x78, 0x73, 0x7b }, /* CLR1 !addr16.0 */
2047
2048 { -1, -1, -1, -1 }
2049 };
2050
2051 /* Relax one section. */
2052
2053 static bfd_boolean
2054 rl78_elf_relax_section
2055 (bfd * abfd,
2056 asection * sec,
2057 struct bfd_link_info * link_info,
2058 bfd_boolean * again)
2059 {
2060 Elf_Internal_Shdr * symtab_hdr;
2061 Elf_Internal_Shdr * shndx_hdr;
2062 Elf_Internal_Rela * internal_relocs;
2063 Elf_Internal_Rela * free_relocs = NULL;
2064 Elf_Internal_Rela * irel;
2065 Elf_Internal_Rela * srel;
2066 Elf_Internal_Rela * irelend;
2067 Elf_Internal_Rela * next_alignment;
2068 bfd_byte * contents = NULL;
2069 bfd_byte * free_contents = NULL;
2070 Elf_Internal_Sym * intsyms = NULL;
2071 Elf_Internal_Sym * free_intsyms = NULL;
2072 Elf_External_Sym_Shndx * shndx_buf = NULL;
2073 bfd_vma pc;
2074 bfd_vma symval ATTRIBUTE_UNUSED = 0;
2075 int pcrel ATTRIBUTE_UNUSED = 0;
2076 int code ATTRIBUTE_UNUSED = 0;
2077 int section_alignment_glue;
2078 int scale;
2079
2080 if (abfd == elf_hash_table (link_info)->dynobj
2081 && strcmp (sec->name, ".plt") == 0)
2082 return rl78_elf_relax_plt_section (abfd, sec, link_info, again);
2083
2084 /* Assume nothing changes. */
2085 *again = FALSE;
2086
2087 /* We don't have to do anything for a relocatable link, if
2088 this section does not have relocs, or if this is not a
2089 code section. */
2090 if (bfd_link_relocatable (link_info)
2091 || (sec->flags & SEC_RELOC) == 0
2092 || sec->reloc_count == 0
2093 || (sec->flags & SEC_CODE) == 0)
2094 return TRUE;
2095
2096 symtab_hdr = & elf_symtab_hdr (abfd);
2097 if (elf_symtab_shndx_list (abfd))
2098 shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
2099 else
2100 shndx_hdr = NULL;
2101
2102 /* Get the section contents. */
2103 if (elf_section_data (sec)->this_hdr.contents != NULL)
2104 contents = elf_section_data (sec)->this_hdr.contents;
2105 /* Go get them off disk. */
2106 else
2107 {
2108 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2109 goto error_return;
2110 elf_section_data (sec)->this_hdr.contents = contents;
2111 }
2112
2113 /* Read this BFD's symbols. */
2114 /* Get cached copy if it exists. */
2115 if (symtab_hdr->contents != NULL)
2116 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2117 else
2118 {
2119 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
2120 symtab_hdr->contents = (bfd_byte *) intsyms;
2121 }
2122
2123 if (shndx_hdr && shndx_hdr->sh_size != 0)
2124 {
2125 bfd_size_type amt;
2126
2127 amt = symtab_hdr->sh_info;
2128 amt *= sizeof (Elf_External_Sym_Shndx);
2129 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2130 if (shndx_buf == NULL)
2131 goto error_return;
2132 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2133 || bfd_bread (shndx_buf, amt, abfd) != amt)
2134 goto error_return;
2135 shndx_hdr->contents = (bfd_byte *) shndx_buf;
2136 }
2137
2138 /* Get a copy of the native relocations. */
2139 internal_relocs = (_bfd_elf_link_read_relocs
2140 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2141 link_info->keep_memory));
2142 if (internal_relocs == NULL)
2143 goto error_return;
2144 if (! link_info->keep_memory)
2145 free_relocs = internal_relocs;
2146
2147 /* The RL_ relocs must be just before the operand relocs they go
2148 with, so we must sort them to guarantee this. We use bubblesort
2149 instead of qsort so we can guarantee that relocs with the same
2150 address remain in the same relative order. */
2151 reloc_bubblesort (internal_relocs, sec->reloc_count);
2152
2153 /* Walk through them looking for relaxing opportunities. */
2154 irelend = internal_relocs + sec->reloc_count;
2155
2156
2157 /* This will either be NULL or a pointer to the next alignment
2158 relocation. */
2159 next_alignment = internal_relocs;
2160
2161 /* We calculate worst case shrinkage caused by alignment directives.
2162 No fool-proof, but better than either ignoring the problem or
2163 doing heavy duty analysis of all the alignment markers in all
2164 input sections. */
2165 section_alignment_glue = 0;
2166 for (irel = internal_relocs; irel < irelend; irel++)
2167 if (ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
2168 && irel->r_addend & RL78_RELAXA_ALIGN)
2169 {
2170 int this_glue = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2171
2172 if (section_alignment_glue < this_glue)
2173 section_alignment_glue = this_glue;
2174 }
2175 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2176 shrinkage. */
2177 section_alignment_glue *= 2;
2178
2179 for (irel = internal_relocs; irel < irelend; irel++)
2180 {
2181 unsigned char *insn;
2182 int nrelocs;
2183
2184 /* The insns we care about are all marked with one of these. */
2185 if (ELF32_R_TYPE (irel->r_info) != R_RL78_RH_RELAX)
2186 continue;
2187
2188 if (irel->r_addend & RL78_RELAXA_ALIGN
2189 || next_alignment == internal_relocs)
2190 {
2191 /* When we delete bytes, we need to maintain all the alignments
2192 indicated. In addition, we need to be careful about relaxing
2193 jumps across alignment boundaries - these displacements
2194 *grow* when we delete bytes. For now, don't shrink
2195 displacements across an alignment boundary, just in case.
2196 Note that this only affects relocations to the same
2197 section. */
2198 next_alignment += 2;
2199 while (next_alignment < irelend
2200 && (ELF32_R_TYPE (next_alignment->r_info) != R_RL78_RH_RELAX
2201 || !(next_alignment->r_addend & RL78_RELAXA_ELIGN)))
2202 next_alignment ++;
2203 if (next_alignment >= irelend || next_alignment->r_offset == 0)
2204 next_alignment = NULL;
2205 }
2206
2207 /* When we hit alignment markers, see if we've shrunk enough
2208 before them to reduce the gap without violating the alignment
2209 requirements. */
2210 if (irel->r_addend & RL78_RELAXA_ALIGN)
2211 {
2212 /* At this point, the next relocation *should* be the ELIGN
2213 end marker. */
2214 Elf_Internal_Rela *erel = irel + 1;
2215 unsigned int alignment, nbytes;
2216
2217 if (ELF32_R_TYPE (erel->r_info) != R_RL78_RH_RELAX)
2218 continue;
2219 if (!(erel->r_addend & RL78_RELAXA_ELIGN))
2220 continue;
2221
2222 alignment = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2223
2224 if (erel->r_offset - irel->r_offset < alignment)
2225 continue;
2226
2227 nbytes = erel->r_offset - irel->r_offset;
2228 nbytes /= alignment;
2229 nbytes *= alignment;
2230
2231 elf32_rl78_relax_delete_bytes (abfd, sec, erel->r_offset - nbytes, nbytes,
2232 next_alignment, erel->r_offset == sec->size);
2233 *again = TRUE;
2234
2235 continue;
2236 }
2237
2238 if (irel->r_addend & RL78_RELAXA_ELIGN)
2239 continue;
2240
2241 insn = contents + irel->r_offset;
2242
2243 nrelocs = irel->r_addend & RL78_RELAXA_RNUM;
2244
2245 /* At this point, we have an insn that is a candidate for linker
2246 relaxation. There are NRELOCS relocs following that may be
2247 relaxed, although each reloc may be made of more than one
2248 reloc entry (such as gp-rel symbols). */
2249
2250 /* Get the value of the symbol referred to by the reloc. Just
2251 in case this is the last reloc in the list, use the RL's
2252 addend to choose between this reloc (no addend) or the next
2253 (yes addend, which means at least one following reloc). */
2254
2255 /* srel points to the "current" reloction for this insn -
2256 actually the last reloc for a given operand, which is the one
2257 we need to update. We check the relaxations in the same
2258 order that the relocations happen, so we'll just push it
2259 along as we go. */
2260 srel = irel;
2261
2262 pc = sec->output_section->vma + sec->output_offset
2263 + srel->r_offset;
2264
2265 #define GET_RELOC \
2266 BFD_ASSERT (nrelocs > 0); \
2267 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2268 pcrel = symval - pc + srel->r_addend; \
2269 nrelocs --;
2270
2271 #define SNIPNR(offset, nbytes) \
2272 elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2273
2274 #define SNIP(offset, nbytes, newtype) \
2275 SNIPNR (offset, nbytes); \
2276 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2277
2278 /* The order of these bit tests must match the order that the
2279 relocs appear in. Since we sorted those by offset, we can
2280 predict them. */
2281
2282 /*----------------------------------------------------------------------*/
2283 /* EF ad BR $rel8 pcrel
2284 ED al ah BR !abs16 abs
2285 EE al ah BR $!rel16 pcrel
2286 EC al ah as BR !!abs20 abs
2287
2288 FD al ah CALL !abs16 abs
2289 FE al ah CALL $!rel16 pcrel
2290 FC al ah as CALL !!abs20 abs
2291
2292 DC ad BC $rel8
2293 DE ad BNC $rel8
2294 DD ad BZ $rel8
2295 DF ad BNZ $rel8
2296 61 C3 ad BH $rel8
2297 61 D3 ad BNH $rel8
2298 61 C8 EF ad SKC ; BR $rel8
2299 61 D8 EF ad SKNC ; BR $rel8
2300 61 E8 EF ad SKZ ; BR $rel8
2301 61 F8 EF ad SKNZ ; BR $rel8
2302 61 E3 EF ad SKH ; BR $rel8
2303 61 F3 EF ad SKNH ; BR $rel8
2304 */
2305
2306 if ((irel->r_addend & RL78_RELAXA_MASK) == RL78_RELAXA_BRA)
2307 {
2308 /* SKIP opcodes that skip non-branches will have a relax tag
2309 but no corresponding symbol to relax against; we just
2310 skip those. */
2311 if (irel->r_addend & RL78_RELAXA_RNUM)
2312 {
2313 GET_RELOC;
2314 }
2315
2316 switch (insn[0])
2317 {
2318 case 0xdc: /* BC */
2319 case 0xdd: /* BZ */
2320 case 0xde: /* BNC */
2321 case 0xdf: /* BNZ */
2322 if (insn[1] == 0x03 && insn[2] == 0xee /* BR */
2323 && (srel->r_offset - irel->r_offset) > 1) /* a B<c> without its own reloc */
2324 {
2325 /* This is a "long" conditional as generated by gas:
2326 DC 03 EE ad.dr */
2327 if (pcrel < 127
2328 && pcrel > -127)
2329 {
2330 insn[0] ^= 0x02; /* invert conditional */
2331 SNIPNR (4, 1);
2332 SNIP (1, 2, R_RL78_DIR8S_PCREL);
2333 insn[1] = pcrel;
2334 *again = TRUE;
2335 }
2336 }
2337 break;
2338
2339 case 0xec: /* BR !!abs20 */
2340
2341 if (pcrel < 127
2342 && pcrel > -127)
2343 {
2344 insn[0] = 0xef;
2345 insn[1] = pcrel;
2346 SNIP (2, 2, R_RL78_DIR8S_PCREL);
2347 *again = TRUE;
2348 }
2349 else if (symval < 65536)
2350 {
2351 insn[0] = 0xed;
2352 insn[1] = symval & 0xff;
2353 insn[2] = symval >> 8;
2354 SNIP (2, 1, R_RL78_DIR16U);
2355 *again = TRUE;
2356 }
2357 else if (pcrel < 32767
2358 && pcrel > -32767)
2359 {
2360 insn[0] = 0xee;
2361 insn[1] = pcrel & 0xff;
2362 insn[2] = pcrel >> 8;
2363 SNIP (2, 1, R_RL78_DIR16S_PCREL);
2364 *again = TRUE;
2365 }
2366 break;
2367
2368 case 0xee: /* BR $!pcrel16 */
2369 case 0xed: /* BR $!abs16 */
2370 if (pcrel < 127
2371 && pcrel > -127)
2372 {
2373 insn[0] = 0xef;
2374 insn[1] = pcrel;
2375 SNIP (2, 1, R_RL78_DIR8S_PCREL);
2376 *again = TRUE;
2377 }
2378 break;
2379
2380 case 0xfc: /* CALL !!abs20 */
2381 if (symval < 65536)
2382 {
2383 insn[0] = 0xfd;
2384 insn[1] = symval & 0xff;
2385 insn[2] = symval >> 8;
2386 SNIP (2, 1, R_RL78_DIR16U);
2387 *again = TRUE;
2388 }
2389 else if (pcrel < 32767
2390 && pcrel > -32767)
2391 {
2392 insn[0] = 0xfe;
2393 insn[1] = pcrel & 0xff;
2394 insn[2] = pcrel >> 8;
2395 SNIP (2, 1, R_RL78_DIR16S_PCREL);
2396 *again = TRUE;
2397 }
2398 break;
2399
2400 case 0x61: /* PREFIX */
2401 /* For SKIP/BR, we change the BR opcode and delete the
2402 SKIP. That way, we don't have to find and change the
2403 relocation for the BR. */
2404 /* Note that, for the case where we're skipping some
2405 other insn, we have no "other" reloc but that's safe
2406 here anyway. */
2407 switch (insn[1])
2408 {
2409 case 0xd3: /* BNH */
2410 case 0xc3: /* BH */
2411 if (insn[2] == 0x03 && insn[3] == 0xee
2412 && (srel->r_offset - irel->r_offset) > 2) /* a B<c> without its own reloc */
2413 {
2414 /* Another long branch by gas:
2415 61 D3 03 EE ad.dr */
2416 if (pcrel < 127
2417 && pcrel > -127)
2418 {
2419 insn[1] ^= 0x10; /* invert conditional */
2420 SNIPNR (5, 1);
2421 SNIP (2, 2, R_RL78_DIR8S_PCREL);
2422 insn[2] = pcrel;
2423 *again = TRUE;
2424 }
2425 }
2426 break;
2427
2428 case 0xc8: /* SKC */
2429 if (insn[2] == 0xef)
2430 {
2431 insn[2] = 0xde; /* BNC */
2432 SNIPNR (0, 2);
2433 }
2434 break;
2435
2436 case 0xd8: /* SKNC */
2437 if (insn[2] == 0xef)
2438 {
2439 insn[2] = 0xdc; /* BC */
2440 SNIPNR (0, 2);
2441 }
2442 break;
2443
2444 case 0xe8: /* SKZ */
2445 if (insn[2] == 0xef)
2446 {
2447 insn[2] = 0xdf; /* BNZ */
2448 SNIPNR (0, 2);
2449 }
2450 break;
2451
2452 case 0xf8: /* SKNZ */
2453 if (insn[2] == 0xef)
2454 {
2455 insn[2] = 0xdd; /* BZ */
2456 SNIPNR (0, 2);
2457 }
2458 break;
2459
2460 case 0xe3: /* SKH */
2461 if (insn[2] == 0xef)
2462 {
2463 insn[2] = 0xd3; /* BNH */
2464 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2465 }
2466 break;
2467
2468 case 0xf3: /* SKNH */
2469 if (insn[2] == 0xef)
2470 {
2471 insn[2] = 0xc3; /* BH */
2472 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2473 }
2474 break;
2475 }
2476 break;
2477 }
2478 }
2479
2480 if ((irel->r_addend & RL78_RELAXA_MASK) == RL78_RELAXA_ADDR16
2481 && nrelocs > 0)
2482 {
2483 /*----------------------------------------------------------------------*/
2484 /* Some insns have both a 16-bit address operand and an 8-bit
2485 variant if the address is within a special range:
2486
2487 Address 16-bit operand SADDR range SFR range
2488 FFF00-FFFFF 0xff00-0xffff 0x00-0xff
2489 FFE20-FFF1F 0xfe20-0xff1f 0x00-0xff
2490
2491 The RELAX_ADDR16[] array has the insn encodings for the
2492 16-bit operand version, as well as the SFR and SADDR
2493 variants. We only need to replace the encodings and
2494 adjust the operand.
2495
2496 Note: we intentionally do not attempt to decode and skip
2497 any ES: prefix, as adding ES: means the addr16 (likely)
2498 no longer points to saddr/sfr space.
2499 */
2500
2501 int is_sfr;
2502 int is_saddr;
2503 int idx;
2504 int poff;
2505
2506 GET_RELOC;
2507
2508 if (0xffe20 <= symval && symval <= 0xfffff)
2509 {
2510
2511 is_saddr = (0xffe20 <= symval && symval <= 0xfff1f);
2512 is_sfr = (0xfff00 <= symval && symval <= 0xfffff);
2513
2514 for (idx = 0; relax_addr16[idx].insn != -1; idx ++)
2515 {
2516 if (relax_addr16[idx].prefix != -1
2517 && insn[0] == relax_addr16[idx].prefix
2518 && insn[1] == relax_addr16[idx].insn)
2519 {
2520 poff = 1;
2521 }
2522 else if (relax_addr16[idx].prefix == -1
2523 && insn[0] == relax_addr16[idx].insn)
2524 {
2525 poff = 0;
2526 }
2527 else
2528 continue;
2529
2530 /* We have a matched insn, and poff is 0 or 1 depending
2531 on the base pattern size. */
2532
2533 if (is_sfr && relax_addr16[idx].insn_for_sfr != -1)
2534 {
2535 insn[poff] = relax_addr16[idx].insn_for_sfr;
2536 SNIP (poff+2, 1, R_RL78_RH_SFR);
2537 }
2538
2539 else if (is_saddr && relax_addr16[idx].insn_for_saddr != -1)
2540 {
2541 insn[poff] = relax_addr16[idx].insn_for_saddr;
2542 SNIP (poff+2, 1, R_RL78_RH_SADDR);
2543 }
2544 }
2545 }
2546 }
2547 /*----------------------------------------------------------------------*/
2548 }
2549
2550 return TRUE;
2551
2552 error_return:
2553 if (free_relocs != NULL)
2554 free (free_relocs);
2555
2556 if (free_contents != NULL)
2557 free (free_contents);
2558
2559 if (shndx_buf != NULL)
2560 {
2561 shndx_hdr->contents = NULL;
2562 free (shndx_buf);
2563 }
2564
2565 if (free_intsyms != NULL)
2566 free (free_intsyms);
2567
2568 return TRUE;
2569 }
2570
2571 \f
2572
2573 #define ELF_ARCH bfd_arch_rl78
2574 #define ELF_MACHINE_CODE EM_RL78
2575 #define ELF_MAXPAGESIZE 0x1000
2576
2577 #define TARGET_LITTLE_SYM rl78_elf32_vec
2578 #define TARGET_LITTLE_NAME "elf32-rl78"
2579
2580 #define elf_info_to_howto_rel NULL
2581 #define elf_info_to_howto rl78_info_to_howto_rela
2582 #define elf_backend_object_p rl78_elf_object_p
2583 #define elf_backend_relocate_section rl78_elf_relocate_section
2584 #define elf_symbol_leading_char ('_')
2585 #define elf_backend_can_gc_sections 1
2586
2587 #define bfd_elf32_bfd_reloc_type_lookup rl78_reloc_type_lookup
2588 #define bfd_elf32_bfd_reloc_name_lookup rl78_reloc_name_lookup
2589 #define bfd_elf32_bfd_set_private_flags rl78_elf_set_private_flags
2590 #define bfd_elf32_bfd_merge_private_bfd_data rl78_elf_merge_private_bfd_data
2591 #define bfd_elf32_bfd_print_private_bfd_data rl78_elf_print_private_bfd_data
2592
2593 #define bfd_elf32_bfd_relax_section rl78_elf_relax_section
2594 #define elf_backend_check_relocs rl78_elf_check_relocs
2595 #define elf_backend_always_size_sections \
2596 rl78_elf_always_size_sections
2597 #define elf_backend_finish_dynamic_sections \
2598 rl78_elf_finish_dynamic_sections
2599
2600 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.094875 seconds and 4 git commands to generate.