1 /* tc-rl78.c -- Assembler for the Renesas RL78
2 Copyright (C) 2011-2015 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS 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, or (at your option)
11 GAS 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.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 #include "struc-symbol.h"
23 #include "safe-ctype.h"
24 #include "dwarf2dbg.h"
26 #include "elf/common.h"
28 #include "rl78-defs.h"
29 #include "filenames.h"
34 const char comment_chars[] = ";";
35 /* Note that input_file.c hand checks for '#' at the beginning of the
36 first line of the input file. This is because the compiler outputs
37 #NO_APP at the beginning of its output. */
38 const char line_comment_chars[] = "#";
39 /* Use something that isn't going to be needed by any expressions or
41 const char line_separator_chars[] = "@";
43 const char EXP_CHARS[] = "eE";
44 const char FLT_CHARS[] = "dD";
46 /* ELF flags to set in the output file header. */
47 static int elf_flags = 0;
49 /*------------------------------------------------------------------*/
51 char * rl78_lex_start;
54 typedef struct rl78_bytesT
67 char type; /* RL78REL_*. */
80 fixS *link_relax_fixP;
85 static rl78_bytesT rl78_bytes;
88 rl78_relax (int type, int pos)
90 rl78_bytes.relax[rl78_bytes.n_relax].type = type;
91 rl78_bytes.relax[rl78_bytes.n_relax].field_pos = pos;
92 rl78_bytes.relax[rl78_bytes.n_relax].val_ofs = rl78_bytes.n_base + rl78_bytes.n_ops;
93 rl78_bytes.n_relax ++;
97 rl78_linkrelax_addr16 (void)
99 rl78_bytes.link_relax |= RL78_RELAXA_ADDR16;
103 rl78_linkrelax_branch (void)
105 rl78_bytes.link_relax |= RL78_RELAXA_BRA;
109 rl78_fixup (expressionS exp, int offsetbits, int nbits, int type)
111 rl78_bytes.fixups[rl78_bytes.n_fixups].exp = exp;
112 rl78_bytes.fixups[rl78_bytes.n_fixups].offset = offsetbits;
113 rl78_bytes.fixups[rl78_bytes.n_fixups].nbits = nbits;
114 rl78_bytes.fixups[rl78_bytes.n_fixups].type = type;
115 rl78_bytes.fixups[rl78_bytes.n_fixups].reloc = exp.X_md;
116 rl78_bytes.n_fixups ++;
119 #define rl78_field_fixup(exp, offset, nbits, type) \
120 rl78_fixup (exp, offset + 8 * rl78_bytes.n_prefix), nbits, type)
122 #define rl78_op_fixup(exp, offset, nbits, type) \
123 rl78_fixup (exp, offset + 8 * (rl78_bytes.n_prefix + rl78_bytes.n_base), nbits, type)
128 rl78_bytes.prefix[0] = p;
129 rl78_bytes.n_prefix = 1;
135 return rl78_bytes.n_prefix;
141 rl78_bytes.base[0] = b1;
142 rl78_bytes.n_base = 1;
146 rl78_base2 (int b1, int b2)
148 rl78_bytes.base[0] = b1;
149 rl78_bytes.base[1] = b2;
150 rl78_bytes.n_base = 2;
154 rl78_base3 (int b1, int b2, int b3)
156 rl78_bytes.base[0] = b1;
157 rl78_bytes.base[1] = b2;
158 rl78_bytes.base[2] = b3;
159 rl78_bytes.n_base = 3;
163 rl78_base4 (int b1, int b2, int b3, int b4)
165 rl78_bytes.base[0] = b1;
166 rl78_bytes.base[1] = b2;
167 rl78_bytes.base[2] = b3;
168 rl78_bytes.base[3] = b4;
169 rl78_bytes.n_base = 4;
172 #define F_PRECISION 2
175 rl78_op (expressionS exp, int nbytes, int type)
179 if ((exp.X_op == O_constant || exp.X_op == O_big)
180 && type != RL78REL_PCREL)
182 if (exp.X_op == O_big && exp.X_add_number <= 0)
185 char * ip = rl78_bytes.ops + rl78_bytes.n_ops;
187 gen_to_words (w, F_PRECISION, 8);
192 rl78_bytes.n_ops += 4;
196 v = exp.X_add_number;
199 rl78_bytes.ops[rl78_bytes.n_ops++] =v & 0xff;
208 && exp.X_md == BFD_RELOC_RL78_CODE)
212 && (exp.X_md == BFD_RELOC_RL78_LO16
213 || exp.X_md == BFD_RELOC_RL78_HI16))
214 as_bad (_("16-bit relocation used in 8-bit operand"));
217 && exp.X_md == BFD_RELOC_RL78_HI8)
218 as_bad (_("8-bit relocation used in 16-bit operand"));
220 rl78_op_fixup (exp, rl78_bytes.n_ops * 8, nbytes * 8, type);
221 memset (rl78_bytes.ops + rl78_bytes.n_ops, 0, nbytes);
222 rl78_bytes.n_ops += nbytes;
226 /* This gets complicated when the field spans bytes, because fields
227 are numbered from the MSB of the first byte as zero, and bits are
228 stored LSB towards the LSB of the byte. Thus, a simple four-bit
229 insertion of 12 at position 4 of 0x00 yields: 0x0b. A three-bit
230 insertion of b'MXL at position 7 is like this:
232 - - - - - - - - - - - - - - - -
236 rl78_field (int val, int pos, int sz)
243 if (val < 0 || val >= (1 << sz))
244 as_bad (_("Value %d doesn't fit in unsigned %d-bit field"), val, sz);
249 if (val < -(1 << (sz - 1)) || val >= (1 << (sz - 1)))
250 as_bad (_("Value %d doesn't fit in signed %d-bit field"), val, sz);
253 /* This code points at 'M' in the above example. */
257 while (bitp + sz > 8)
262 svalm = val >> (sz - ssz);
263 svalm = svalm & ((1 << ssz) - 1);
264 svalm = svalm << (8 - bitp - ssz);
265 gas_assert (bytep < rl78_bytes.n_base);
266 rl78_bytes.base[bytep] |= svalm;
272 valm = val & ((1 << sz) - 1);
273 valm = valm << (8 - bitp - sz);
274 gas_assert (bytep < rl78_bytes.n_base);
275 rl78_bytes.base[bytep] |= valm;
278 /*------------------------------------------------------------------*/
282 OPTION_RELAX = OPTION_MD_BASE,
286 OPTION_32BIT_DOUBLES,
287 OPTION_64BIT_DOUBLES,
290 #define RL78_SHORTOPTS ""
291 const char * md_shortopts = RL78_SHORTOPTS;
293 /* Assembler options. */
294 struct option md_longopts[] =
296 {"relax", no_argument, NULL, OPTION_RELAX},
297 {"mg10", no_argument, NULL, OPTION_G10},
298 {"mg13", no_argument, NULL, OPTION_G13},
299 {"mg14", no_argument, NULL, OPTION_G14},
300 {"mrl78", no_argument, NULL, OPTION_G14},
301 {"m32bit-doubles", no_argument, NULL, OPTION_32BIT_DOUBLES},
302 {"m64bit-doubles", no_argument, NULL, OPTION_64BIT_DOUBLES},
303 {NULL, no_argument, NULL, 0}
305 size_t md_longopts_size = sizeof (md_longopts);
308 md_parse_option (int c, char * arg ATTRIBUTE_UNUSED)
317 elf_flags &= ~ E_FLAG_RL78_CPU_MASK;
318 elf_flags |= E_FLAG_RL78_G10;
322 elf_flags &= ~ E_FLAG_RL78_CPU_MASK;
323 elf_flags |= E_FLAG_RL78_G13;
327 elf_flags &= ~ E_FLAG_RL78_CPU_MASK;
328 elf_flags |= E_FLAG_RL78_G14;
331 case OPTION_32BIT_DOUBLES:
332 elf_flags &= ~ E_FLAG_RL78_64BIT_DOUBLES;
335 case OPTION_64BIT_DOUBLES:
336 elf_flags |= E_FLAG_RL78_64BIT_DOUBLES;
345 return (elf_flags & E_FLAG_RL78_CPU_MASK) == E_FLAG_RL78_G10;
351 return (elf_flags & E_FLAG_RL78_CPU_MASK) == E_FLAG_RL78_G13;
357 return (elf_flags & E_FLAG_RL78_CPU_MASK) == E_FLAG_RL78_G14;
361 md_show_usage (FILE * stream)
363 fprintf (stream, _(" RL78 specific command line options:\n"));
364 fprintf (stream, _(" --mrelax Enable link time relaxation\n"));
365 fprintf (stream, _(" --mg10 Enable support for G10 variant\n"));
366 fprintf (stream, _(" --mg13 Selects the G13 core.\n"));
367 fprintf (stream, _(" --mg14 Selects the G14 core [default]\n"));
368 fprintf (stream, _(" --mrl78 Alias for --mg14\n"));
369 fprintf (stream, _(" --m32bit-doubles [default]\n"));
370 fprintf (stream, _(" --m64bit-doubles Source code uses 64-bit doubles\n"));
374 s_bss (int ignore ATTRIBUTE_UNUSED)
378 temp = get_absolute_expression ();
379 subseg_set (bss_section, (subsegT) temp);
380 demand_empty_rest_of_line ();
384 rl78_float_cons (int ignore ATTRIBUTE_UNUSED)
386 if (elf_flags & E_FLAG_RL78_64BIT_DOUBLES)
387 return float_cons ('d');
388 return float_cons ('f');
391 /* The target specific pseudo-ops which we support. */
392 const pseudo_typeS md_pseudo_table[] =
394 /* Our "standard" pseudos. */
395 { "double", rl78_float_cons, 'd' },
397 { "3byte", cons, 3 },
401 /* End of list marker. */
415 /* Set the ELF specific flags. */
417 rl78_elf_final_processing (void)
419 elf_elfheader (stdoutput)->e_flags |= elf_flags;
422 /* Write a value out to the object file, using the appropriate endianness. */
424 md_number_to_chars (char * buf, valueT val, int n)
426 number_to_chars_littleendian (buf, val, n);
430 require_end_of_expr (char *fname)
432 while (* input_line_pointer == ' '
433 || * input_line_pointer == '\t')
434 input_line_pointer ++;
436 if (! * input_line_pointer
437 || strchr ("\n\r,", * input_line_pointer)
438 || strchr (comment_chars, * input_line_pointer)
439 || strchr (line_comment_chars, * input_line_pointer)
440 || strchr (line_separator_chars, * input_line_pointer))
443 as_bad (_("%%%s() must be outermost term in expression"), fname);
453 { "code", BFD_RELOC_RL78_CODE },
454 { "lo16", BFD_RELOC_RL78_LO16 },
455 { "hi16", BFD_RELOC_RL78_HI16 },
456 { "hi8", BFD_RELOC_RL78_HI8 },
461 md_operand (expressionS * exp ATTRIBUTE_UNUSED)
466 for (i = 0; reloc_functions[i].fname; i++)
468 int flen = strlen (reloc_functions[i].fname);
470 if (input_line_pointer[0] == '%'
471 && strncasecmp (input_line_pointer + 1, reloc_functions[i].fname, flen) == 0
472 && input_line_pointer[flen + 1] == '(')
474 reloc = reloc_functions[i].reloc;
475 input_line_pointer += flen + 2;
483 if (* input_line_pointer == ')')
484 input_line_pointer ++;
488 require_end_of_expr (reloc_functions[i].fname);
492 rl78_frag_init (fragS * fragP)
494 if (rl78_bytes.n_relax || rl78_bytes.link_relax)
496 fragP->tc_frag_data = malloc (sizeof (rl78_bytesT));
497 memcpy (fragP->tc_frag_data, & rl78_bytes, sizeof (rl78_bytesT));
500 fragP->tc_frag_data = 0;
503 /* When relaxing, we need to output a reloc for any .align directive
504 so that we can retain this alignment as we adjust opcode sizes. */
506 rl78_handle_align (fragS * frag)
509 && (frag->fr_type == rs_align
510 || frag->fr_type == rs_align_code)
511 && frag->fr_address + frag->fr_fix > 0
512 && frag->fr_offset > 0
513 && now_seg != bss_section)
515 fix_new (frag, frag->fr_fix, 0,
516 &abs_symbol, RL78_RELAXA_ALIGN + frag->fr_offset,
517 0, BFD_RELOC_RL78_RELAX);
518 /* For the purposes of relaxation, this relocation is attached
519 to the byte *after* the alignment - i.e. the byte that must
521 fix_new (frag->fr_next, 0, 0,
522 &abs_symbol, RL78_RELAXA_ELIGN + frag->fr_offset,
523 0, BFD_RELOC_RL78_RELAX);
528 md_atof (int type, char * litP, int * sizeP)
530 return ieee_md_atof (type, litP, sizeP, target_big_endian);
534 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
539 #define APPEND(B, N_B) \
540 if (rl78_bytes.N_B) \
542 memcpy (bytes + idx, rl78_bytes.B, rl78_bytes.N_B); \
543 idx += rl78_bytes.N_B; \
548 md_assemble (char * str)
551 fragS * frag_then = frag_now;
557 /*printf("\033[32mASM: %s\033[0m\n", str);*/
559 dwarf2_emit_insn (0);
561 memset (& rl78_bytes, 0, sizeof (rl78_bytes));
563 rl78_lex_init (str, str + strlen (str));
567 /* This simplifies the relaxation code. */
568 if (rl78_bytes.n_relax || rl78_bytes.link_relax)
570 int olen = rl78_bytes.n_prefix + rl78_bytes.n_base + rl78_bytes.n_ops;
571 /* We do it this way because we want the frag to have the
572 rl78_bytes in it, which we initialize above. The extra bytes
574 bytes = frag_more (olen + 3);
575 frag_then = frag_now;
576 frag_variant (rs_machine_dependent,
577 olen /* max_chars */,
583 frag_then->fr_opcode = bytes;
584 frag_then->fr_fix = olen + (bytes - frag_then->fr_literal);
585 frag_then->fr_subtype = olen;
586 frag_then->fr_var = 0;
590 bytes = frag_more (rl78_bytes.n_prefix + rl78_bytes.n_base + rl78_bytes.n_ops);
591 frag_then = frag_now;
594 APPEND (prefix, n_prefix);
595 APPEND (base, n_base);
598 if (rl78_bytes.link_relax)
602 f = fix_new (frag_then,
603 (char *) bytes - frag_then->fr_literal,
606 rl78_bytes.link_relax | rl78_bytes.n_fixups,
608 BFD_RELOC_RL78_RELAX);
609 frag_then->tc_frag_data->link_relax_fixP = f;
612 for (i = 0; i < rl78_bytes.n_fixups; i ++)
614 /* index: [nbytes][type] */
615 static int reloc_map[5][4] =
618 { BFD_RELOC_8, BFD_RELOC_8_PCREL },
619 { BFD_RELOC_16, BFD_RELOC_16_PCREL },
620 { BFD_RELOC_24, BFD_RELOC_24_PCREL },
621 { BFD_RELOC_32, BFD_RELOC_32_PCREL },
625 idx = rl78_bytes.fixups[i].offset / 8;
626 rel = reloc_map [rl78_bytes.fixups[i].nbits / 8][(int) rl78_bytes.fixups[i].type];
628 if (rl78_bytes.fixups[i].reloc)
629 rel = rl78_bytes.fixups[i].reloc;
631 if (frag_then->tc_frag_data)
632 exp = & frag_then->tc_frag_data->fixups[i].exp;
634 exp = & rl78_bytes.fixups[i].exp;
636 f = fix_new_exp (frag_then,
637 (char *) bytes + idx - frag_then->fr_literal,
638 rl78_bytes.fixups[i].nbits / 8,
640 rl78_bytes.fixups[i].type == RL78REL_PCREL ? 1 : 0,
642 if (frag_then->tc_frag_data)
643 frag_then->tc_frag_data->fixups[i].fixP = f;
648 rl78_cons_fix_new (fragS * frag,
653 bfd_reloc_code_real_type type;
671 as_bad (_("unsupported constant size %d\n"), size);
677 case BFD_RELOC_RL78_CODE:
681 case BFD_RELOC_RL78_LO16:
682 case BFD_RELOC_RL78_HI16:
685 /* Fixups to assembler generated expressions do not use %hi or %lo. */
687 as_bad (_("%%hi16/%%lo16 only applies to .short or .hword"));
692 case BFD_RELOC_RL78_HI8:
695 /* Fixups to assembler generated expressions do not use %hi or %lo. */
697 as_bad (_("%%hi8 only applies to .byte"));
706 if (exp->X_op == O_subtract && exp->X_op_symbol)
708 if (size != 4 && size != 2 && size != 1)
709 as_bad (_("difference of two symbols only supported with .long, .short, or .byte"));
711 type = BFD_RELOC_RL78_DIFF;
714 fixP = fix_new_exp (frag, where, (int) size, exp, 0, type);
717 /* These are intended to have values larger than the container,
718 since the backend puts only the portion we need in it.
719 However, we don't have a backend-specific reloc for them as
720 they're handled with complex relocations. */
721 case BFD_RELOC_RL78_LO16:
722 case BFD_RELOC_RL78_HI16:
723 case BFD_RELOC_RL78_HI8:
724 fixP->fx_no_overflow = 1;
732 /*----------------------------------------------------------------------*/
733 /* To recap: we estimate everything based on md_estimate_size, then
734 adjust based on rl78_relax_frag. When it all settles, we call
735 md_convert frag to update the bytes. The relaxation types and
736 relocations are in fragP->tc_frag_data, which is a copy of that
739 Our scheme is as follows: fr_fix has the size of the smallest
740 opcode (like BRA.S). We store the number of total bytes we need in
741 fr_subtype. When we're done relaxing, we use fr_subtype and the
742 existing opcode bytes to figure out what actual opcode we need to
743 put in there. If the fixup isn't resolvable now, we use the
746 #define TRACE_RELAX 0
747 #define tprintf if (TRACE_RELAX) printf
760 /* We're looking for these types of relaxations:
762 BT 00110001 sbit0cc1 addr---- (cc is 10 (BF) or 01 (BT))
763 B~T 00110001 sbit0cc1 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
765 BT sfr 00110001 sbit0cc0 sfr----- addr----
766 BT ES: 00010001 00101110 sbit0cc1 addr----
769 B~C 110111cc 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
771 BH 01100001 110c0011 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
772 B~H 01100001 110c0011 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
775 /* Given the opcode bytes at OP, figure out which opcode it is and
776 return the type of opcode. We use this to re-encode the opcode as
777 a different size later. */
780 rl78_opcode_type (char * op)
783 && ((op[1] & 0x0f) == 0x05
784 || (op[1] & 0x0f) == 0x03))
788 && ((op[1] & 0x0f) == 0x04
789 || (op[1] & 0x0f) == 0x02))
794 && ((op[2] & 0x0f) == 0x05
795 || (op[2] & 0x0f) == 0x03))
798 if ((op[0] & 0xfc) == 0xdc)
802 && (op[1] & 0xef) == 0xc3)
808 /* Returns zero if *addrP has the target address. Else returns nonzero
809 if we cannot compute the target address yet. */
812 rl78_frag_fix_value (fragS * fragP,
820 rl78_bytesT * b = fragP->tc_frag_data;
821 expressionS * exp = & b->fixups[which].exp;
823 if (need_diff && exp->X_op != O_subtract)
826 if (exp->X_add_symbol)
828 if (S_FORCE_RELOC (exp->X_add_symbol, 1))
830 if (S_GET_SEGMENT (exp->X_add_symbol) != segment)
832 addr += S_GET_VALUE (exp->X_add_symbol);
835 if (exp->X_op_symbol)
837 if (exp->X_op != O_subtract)
839 if (S_FORCE_RELOC (exp->X_op_symbol, 1))
841 if (S_GET_SEGMENT (exp->X_op_symbol) != segment)
843 addr -= S_GET_VALUE (exp->X_op_symbol);
847 addr += exp->X_add_number;
852 /* Estimate how big the opcode is after this relax pass. The return
853 value is the difference between fr_fix and the actual size. We
854 compute the total size in rl78_relax_frag and store it in fr_subtype,
855 so we only need to subtract fx_fix and return it. */
858 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED, segT segment ATTRIBUTE_UNUSED)
863 /* This is the size of the opcode that's accounted for in fr_fix. */
864 opfixsize = fragP->fr_fix - (fragP->fr_opcode - fragP->fr_literal);
865 /* This is the size of the opcode that isn't. */
866 delta = (fragP->fr_subtype - opfixsize);
868 tprintf (" -> opfixsize %d delta %d\n", opfixsize, delta);
872 /* Given the new addresses for this relax pass, figure out how big
873 each opcode must be. We store the total number of bytes needed in
874 fr_subtype. The return value is the difference between the size
875 after the last pass and the size after this pass, so we use the old
876 fr_subtype to calculate the difference. */
879 rl78_relax_frag (segT segment ATTRIBUTE_UNUSED, fragS * fragP, long stretch)
881 addressT addr0, sym_addr;
884 int oldsize = fragP->fr_subtype;
885 int newsize = oldsize;
889 mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
891 /* If we ever get more than one reloc per opcode, this is the one
895 optype = rl78_opcode_type (fragP->fr_opcode);
896 /* Try to get the target address. */
897 if (rl78_frag_fix_value (fragP, segment, ri, & addr0,
898 fragP->tc_frag_data->relax[ri].type != RL78_RELAX_BRANCH,
901 /* If we don't, we must use the maximum size for the linker. */
902 switch (fragP->tc_frag_data->relax[ri].type)
904 case RL78_RELAX_BRANCH:
927 fragP->fr_subtype = newsize;
928 tprintf (" -> new %d old %d delta %d (external)\n", newsize, oldsize, newsize-oldsize);
929 return newsize - oldsize;
935 switch (fragP->tc_frag_data->relax[ri].type)
937 case RL78_RELAX_BRANCH:
938 disp = (int) addr0 - (int) mypc;
943 if (disp >= -128 && (disp - (oldsize-2)) <= 127)
950 if (disp >= -128 && (disp - (oldsize-3)) <= 127)
956 if (disp >= -128 && (disp - (oldsize-1)) <= 127)
962 if (disp >= -128 && (disp - (oldsize-2)) <= 127)
974 /* This prevents infinite loops in align-heavy sources. */
975 if (newsize < oldsize)
977 if (fragP->tc_frag_data->times_shrank > 10
978 && fragP->tc_frag_data->times_grown > 10)
980 if (fragP->tc_frag_data->times_shrank < 20)
981 fragP->tc_frag_data->times_shrank ++;
983 else if (newsize > oldsize)
985 if (fragP->tc_frag_data->times_grown < 20)
986 fragP->tc_frag_data->times_grown ++;
989 fragP->fr_subtype = newsize;
990 tprintf (" -> new %d old %d delta %d\n", newsize, oldsize, newsize-oldsize);
991 return newsize - oldsize;
994 /* This lets us test for the opcode type and the desired size in a
996 #define OPCODE(type,size) ((type) * 16 + (size))
998 /* Given the opcode stored in fr_opcode and the number of bytes we
999 think we need, encode a new opcode. We stored a pointer to the
1000 fixup for this opcode in the tc_frag_data structure. If we can do
1001 the fixup here, we change the relocation type to "none" (we test
1002 for that in tc_gen_reloc) else we change it to the right type for
1003 the new (biggest) opcode. */
1006 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED,
1007 segT segment ATTRIBUTE_UNUSED,
1008 fragS * fragP ATTRIBUTE_UNUSED)
1010 rl78_bytesT * rl78b = fragP->tc_frag_data;
1011 addressT addr0, mypc;
1013 int reloc_type, reloc_adjust;
1014 char * op = fragP->fr_opcode;
1017 int fi = (rl78b->n_fixups > 1) ? 1 : 0;
1018 fixS * fix = rl78b->fixups[fi].fixP;
1020 /* If we ever get more than one reloc per opcode, this is the one
1024 /* We used a new frag for this opcode, so the opcode address should
1025 be the frag address. */
1026 mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
1027 tprintf ("\033[32mmypc: 0x%x\033[0m\n", (int)mypc);
1029 /* Try to get the target address. If we fail here, we just use the
1031 if (rl78_frag_fix_value (fragP, segment, 0, & addr0,
1032 fragP->tc_frag_data->relax[ri].type != RL78_RELAX_BRANCH, 0))
1034 /* We don't know the target address. */
1038 tprintf ("unknown addr ? - %x = ?\n", (int)mypc);
1042 /* We know the target address, and it's in addr0. */
1043 disp = (int) addr0 - (int) mypc;
1044 tprintf ("known addr %x - %x = %d\n", (int)addr0, (int)mypc, disp);
1050 reloc_type = BFD_RELOC_NONE;
1053 switch (fragP->tc_frag_data->relax[ri].type)
1055 case RL78_RELAX_BRANCH:
1056 switch (OPCODE (rl78_opcode_type (fragP->fr_opcode), fragP->fr_subtype))
1059 case OPCODE (OT_bt, 3): /* BT A,$ - no change. */
1064 case OPCODE (OT_bt, 6): /* BT A,$ - long version. */
1066 op[1] ^= 0x06; /* toggle conditional. */
1067 op[2] = 3; /* displacement over long branch. */
1069 op[3] = 0xEE; /* BR $!addr20 */
1070 op[4] = disp & 0xff;
1072 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1076 case OPCODE (OT_bt_sfr, 4): /* BT PSW,$ - no change. */
1081 case OPCODE (OT_bt_sfr, 7): /* BT PSW,$ - long version. */
1083 op[1] ^= 0x06; /* toggle conditional. */
1084 op[3] = 3; /* displacement over long branch. */
1086 op[4] = 0xEE; /* BR $!addr20 */
1087 op[5] = disp & 0xff;
1089 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1093 case OPCODE (OT_bt_es, 4): /* BT ES:[HL],$ - no change. */
1098 case OPCODE (OT_bt_es, 7): /* BT PSW,$ - long version. */
1100 op[2] ^= 0x06; /* toggle conditional. */
1101 op[3] = 3; /* displacement over long branch. */
1103 op[4] = 0xEE; /* BR $!addr20 */
1104 op[5] = disp & 0xff;
1106 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1110 case OPCODE (OT_bc, 2): /* BC $ - no change. */
1115 case OPCODE (OT_bc, 5): /* BC $ - long version. */
1117 op[0] ^= 0x02; /* toggle conditional. */
1120 op[2] = 0xEE; /* BR $!addr20 */
1121 op[3] = disp & 0xff;
1123 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1127 case OPCODE (OT_bh, 3): /* BH $ - no change. */
1132 case OPCODE (OT_bh, 6): /* BC $ - long version. */
1134 op[1] ^= 0x10; /* toggle conditional. */
1137 op[3] = 0xEE; /* BR $!addr20 */
1138 op[4] = disp & 0xff;
1140 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1145 fprintf(stderr, "Missed case %d %d at 0x%lx\n",
1146 rl78_opcode_type (fragP->fr_opcode), fragP->fr_subtype, mypc);
1153 if (rl78b->n_fixups)
1155 reloc_type = fix->fx_r_type;
1161 if (rl78b->n_fixups)
1164 fix->fx_r_type = reloc_type;
1165 fix->fx_where += reloc_adjust;
1168 case BFD_RELOC_NONE:
1174 case BFD_RELOC_16_PCREL:
1180 fragP->fr_fix = fragP->fr_subtype + (fragP->fr_opcode - fragP->fr_literal);
1181 tprintf ("fragP->fr_fix now %ld (%d + (%p - %p)\n", (long) fragP->fr_fix,
1182 fragP->fr_subtype, fragP->fr_opcode, fragP->fr_literal);
1185 tprintf ("compare 0x%lx vs 0x%lx - 0x%lx = 0x%lx (%p)\n",
1186 (long)fragP->fr_fix,
1187 (long)fragP->fr_next->fr_address, (long)fragP->fr_address,
1188 (long)(fragP->fr_next->fr_address - fragP->fr_address),
1191 if (fragP->fr_next != NULL
1192 && ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
1194 as_bad (_("bad frag at %p : fix %ld addr %ld %ld \n"), fragP,
1195 (long) fragP->fr_fix,
1196 (long) fragP->fr_address, (long) fragP->fr_next->fr_address);
1199 /* End of relaxation code.
1200 ----------------------------------------------------------------------*/
1204 tc_gen_reloc (asection * seg ATTRIBUTE_UNUSED, fixS * fixp)
1206 static arelent * reloc[8];
1209 if (fixp->fx_r_type == BFD_RELOC_NONE)
1216 && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
1218 fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
1219 fixp->fx_subsy = NULL;
1222 reloc[0] = (arelent *) xmalloc (sizeof (arelent));
1223 reloc[0]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
1224 * reloc[0]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1225 reloc[0]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1226 reloc[0]->addend = fixp->fx_offset;
1228 if (fixp->fx_r_type == BFD_RELOC_RL78_32_OP
1231 fixp->fx_r_type = BFD_RELOC_RL78_DIFF;
1234 #define OPX(REL,SYM,ADD) \
1235 reloc[rp] = (arelent *) xmalloc (sizeof (arelent)); \
1236 reloc[rp]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); \
1237 reloc[rp]->howto = bfd_reloc_type_lookup (stdoutput, REL); \
1238 reloc[rp]->addend = ADD; \
1239 * reloc[rp]->sym_ptr_ptr = SYM; \
1240 reloc[rp]->address = fixp->fx_frag->fr_address + fixp->fx_where; \
1242 #define OPSYM(SYM) OPX(BFD_RELOC_RL78_SYM, SYM, 0)
1243 #define OPIMM(IMM) OPX(BFD_RELOC_RL78_SYM, abs_symbol.bsym, IMM)
1244 #define OP(OP) OPX(BFD_RELOC_RL78_##OP, *reloc[0]->sym_ptr_ptr, 0)
1245 #define SYM0() reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RL78_SYM)
1249 /* Certain BFD relocations cannot be translated directly into
1250 a single (non-Red Hat) RL78 relocation, but instead need
1251 multiple RL78 relocations - handle them here. */
1252 switch (fixp->fx_r_type)
1254 case BFD_RELOC_RL78_DIFF:
1256 OPSYM (symbol_get_bfdsym (fixp->fx_subsy));
1259 switch (fixp->fx_size)
1273 case BFD_RELOC_RL78_NEG32:
1279 case BFD_RELOC_RL78_CODE:
1280 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RL78_16U);
1284 case BFD_RELOC_RL78_LO16:
1291 case BFD_RELOC_RL78_HI16:
1298 case BFD_RELOC_RL78_HI8:
1308 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
1317 rl78_validate_fix_sub (struct fix * f)
1319 /* We permit the subtraction of two symbols in a few cases. */
1320 /* mov #sym1-sym2, R3 */
1321 if (f->fx_r_type == BFD_RELOC_RL78_32_OP)
1323 /* .long sym1-sym2 */
1324 if (f->fx_r_type == BFD_RELOC_RL78_DIFF
1326 && (f->fx_size == 4 || f->fx_size == 2 || f->fx_size == 1))
1332 md_pcrel_from_section (fixS * fixP, segT sec)
1336 if (fixP->fx_addsy != NULL
1337 && (! S_IS_DEFINED (fixP->fx_addsy)
1338 || S_GET_SEGMENT (fixP->fx_addsy) != sec))
1339 /* The symbol is undefined (or is defined but not in this section).
1340 Let the linker figure it out. */
1343 rv = fixP->fx_frag->fr_address + fixP->fx_where;
1344 switch (fixP->fx_r_type)
1346 case BFD_RELOC_8_PCREL:
1349 case BFD_RELOC_16_PCREL:
1359 md_apply_fix (struct fix * f ATTRIBUTE_UNUSED,
1360 valueT * t ATTRIBUTE_UNUSED,
1361 segT s ATTRIBUTE_UNUSED)
1366 if (f->fx_addsy && S_FORCE_RELOC (f->fx_addsy, 1))
1368 if (f->fx_subsy && S_FORCE_RELOC (f->fx_subsy, 1))
1371 op = f->fx_frag->fr_literal + f->fx_where;
1372 val = (unsigned long) * t;
1374 switch (f->fx_r_type)
1376 case BFD_RELOC_NONE:
1379 case BFD_RELOC_RL78_RELAX:
1383 case BFD_RELOC_8_PCREL:
1384 if ((long)val < -128 || (long)val > 127)
1385 as_bad_where (f->fx_file, f->fx_line,
1386 _("value of %ld too large for 8-bit branch"),
1390 case BFD_RELOC_RL78_SADDR: /* We need to store the 8 LSB, but this works. */
1394 case BFD_RELOC_16_PCREL:
1395 if ((long)val < -32768 || (long)val > 32767)
1396 as_bad_where (f->fx_file, f->fx_line,
1397 _("value of %ld too large for 16-bit branch"),
1401 case BFD_RELOC_RL78_CODE:
1419 case BFD_RELOC_RL78_DIFF:
1429 case BFD_RELOC_RL78_HI8:
1434 case BFD_RELOC_RL78_HI16:
1440 case BFD_RELOC_RL78_LO16:
1446 as_bad (_("Unknown reloc in md_apply_fix: %s"),
1447 bfd_get_reloc_code_name (f->fx_r_type));
1451 if (f->fx_addsy == NULL)
1456 md_section_align (segT segment, valueT size)
1458 int align = bfd_get_section_alignment (stdoutput, segment);
1459 return ((size + (1 << align) - 1) & (-1 << align));