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