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