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;
343 md_show_usage (FILE * stream)
345 fprintf (stream, _(" RL78 specific command line options:\n"));
346 fprintf (stream, _(" --mrelax Enable link time relaxation\n"));
347 fprintf (stream, _(" --mg10 Enable support for G10 variant\n"));
348 fprintf (stream, _(" --mg13 Selects the G13 core.\n"));
349 fprintf (stream, _(" --mg14 Selects the G14 core [default]\n"));
350 fprintf (stream, _(" --mrl78 Alias for --mg14\n"));
351 fprintf (stream, _(" --m32bit-doubles [default]\n"));
352 fprintf (stream, _(" --m64bit-doubles Source code uses 64-bit doubles\n"));
356 s_bss (int ignore ATTRIBUTE_UNUSED)
360 temp = get_absolute_expression ();
361 subseg_set (bss_section, (subsegT) temp);
362 demand_empty_rest_of_line ();
366 rl78_float_cons (int ignore ATTRIBUTE_UNUSED)
368 if (elf_flags & E_FLAG_RL78_64BIT_DOUBLES)
369 return float_cons ('d');
370 return float_cons ('f');
373 /* The target specific pseudo-ops which we support. */
374 const pseudo_typeS md_pseudo_table[] =
376 /* Our "standard" pseudos. */
377 { "double", rl78_float_cons, 'd' },
379 { "3byte", cons, 3 },
383 /* End of list marker. */
397 /* Set the ELF specific flags. */
399 rl78_elf_final_processing (void)
401 elf_elfheader (stdoutput)->e_flags |= elf_flags;
404 /* Write a value out to the object file, using the appropriate endianness. */
406 md_number_to_chars (char * buf, valueT val, int n)
408 number_to_chars_littleendian (buf, val, n);
412 require_end_of_expr (char *fname)
414 while (* input_line_pointer == ' '
415 || * input_line_pointer == '\t')
416 input_line_pointer ++;
418 if (! * input_line_pointer
419 || strchr ("\n\r,", * input_line_pointer)
420 || strchr (comment_chars, * input_line_pointer)
421 || strchr (line_comment_chars, * input_line_pointer)
422 || strchr (line_separator_chars, * input_line_pointer))
425 as_bad (_("%%%s() must be outermost term in expression"), fname);
435 { "code", BFD_RELOC_RL78_CODE },
436 { "lo16", BFD_RELOC_RL78_LO16 },
437 { "hi16", BFD_RELOC_RL78_HI16 },
438 { "hi8", BFD_RELOC_RL78_HI8 },
443 md_operand (expressionS * exp ATTRIBUTE_UNUSED)
448 for (i = 0; reloc_functions[i].fname; i++)
450 int flen = strlen (reloc_functions[i].fname);
452 if (input_line_pointer[0] == '%'
453 && strncasecmp (input_line_pointer + 1, reloc_functions[i].fname, flen) == 0
454 && input_line_pointer[flen + 1] == '(')
456 reloc = reloc_functions[i].reloc;
457 input_line_pointer += flen + 2;
465 if (* input_line_pointer == ')')
466 input_line_pointer ++;
470 require_end_of_expr (reloc_functions[i].fname);
474 rl78_frag_init (fragS * fragP)
476 if (rl78_bytes.n_relax || rl78_bytes.link_relax)
478 fragP->tc_frag_data = malloc (sizeof (rl78_bytesT));
479 memcpy (fragP->tc_frag_data, & rl78_bytes, sizeof (rl78_bytesT));
482 fragP->tc_frag_data = 0;
485 /* When relaxing, we need to output a reloc for any .align directive
486 so that we can retain this alignment as we adjust opcode sizes. */
488 rl78_handle_align (fragS * frag)
491 && (frag->fr_type == rs_align
492 || frag->fr_type == rs_align_code)
493 && frag->fr_address + frag->fr_fix > 0
494 && frag->fr_offset > 0
495 && now_seg != bss_section)
497 fix_new (frag, frag->fr_fix, 0,
498 &abs_symbol, RL78_RELAXA_ALIGN + frag->fr_offset,
499 0, BFD_RELOC_RL78_RELAX);
500 /* For the purposes of relaxation, this relocation is attached
501 to the byte *after* the alignment - i.e. the byte that must
503 fix_new (frag->fr_next, 0, 0,
504 &abs_symbol, RL78_RELAXA_ELIGN + frag->fr_offset,
505 0, BFD_RELOC_RL78_RELAX);
510 md_atof (int type, char * litP, int * sizeP)
512 return ieee_md_atof (type, litP, sizeP, target_big_endian);
516 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
521 #define APPEND(B, N_B) \
522 if (rl78_bytes.N_B) \
524 memcpy (bytes + idx, rl78_bytes.B, rl78_bytes.N_B); \
525 idx += rl78_bytes.N_B; \
530 md_assemble (char * str)
533 fragS * frag_then = frag_now;
539 /*printf("\033[32mASM: %s\033[0m\n", str);*/
541 dwarf2_emit_insn (0);
543 memset (& rl78_bytes, 0, sizeof (rl78_bytes));
545 rl78_lex_init (str, str + strlen (str));
549 /* This simplifies the relaxation code. */
550 if (rl78_bytes.n_relax || rl78_bytes.link_relax)
552 int olen = rl78_bytes.n_prefix + rl78_bytes.n_base + rl78_bytes.n_ops;
553 /* We do it this way because we want the frag to have the
554 rl78_bytes in it, which we initialize above. The extra bytes
556 bytes = frag_more (olen + 3);
557 frag_then = frag_now;
558 frag_variant (rs_machine_dependent,
559 olen /* max_chars */,
565 frag_then->fr_opcode = bytes;
566 frag_then->fr_fix = olen + (bytes - frag_then->fr_literal);
567 frag_then->fr_subtype = olen;
568 frag_then->fr_var = 0;
572 bytes = frag_more (rl78_bytes.n_prefix + rl78_bytes.n_base + rl78_bytes.n_ops);
573 frag_then = frag_now;
576 APPEND (prefix, n_prefix);
577 APPEND (base, n_base);
580 if (rl78_bytes.link_relax)
584 f = fix_new (frag_then,
585 (char *) bytes - frag_then->fr_literal,
588 rl78_bytes.link_relax | rl78_bytes.n_fixups,
590 BFD_RELOC_RL78_RELAX);
591 frag_then->tc_frag_data->link_relax_fixP = f;
594 for (i = 0; i < rl78_bytes.n_fixups; i ++)
596 /* index: [nbytes][type] */
597 static int reloc_map[5][4] =
600 { BFD_RELOC_8, BFD_RELOC_8_PCREL },
601 { BFD_RELOC_16, BFD_RELOC_16_PCREL },
602 { BFD_RELOC_24, BFD_RELOC_24_PCREL },
603 { BFD_RELOC_32, BFD_RELOC_32_PCREL },
607 idx = rl78_bytes.fixups[i].offset / 8;
608 rel = reloc_map [rl78_bytes.fixups[i].nbits / 8][(int) rl78_bytes.fixups[i].type];
610 if (rl78_bytes.fixups[i].reloc)
611 rel = rl78_bytes.fixups[i].reloc;
613 if (frag_then->tc_frag_data)
614 exp = & frag_then->tc_frag_data->fixups[i].exp;
616 exp = & rl78_bytes.fixups[i].exp;
618 f = fix_new_exp (frag_then,
619 (char *) bytes + idx - frag_then->fr_literal,
620 rl78_bytes.fixups[i].nbits / 8,
622 rl78_bytes.fixups[i].type == RL78REL_PCREL ? 1 : 0,
624 if (frag_then->tc_frag_data)
625 frag_then->tc_frag_data->fixups[i].fixP = f;
630 rl78_cons_fix_new (fragS * frag,
635 bfd_reloc_code_real_type type;
653 as_bad (_("unsupported constant size %d\n"), size);
659 case BFD_RELOC_RL78_CODE:
663 case BFD_RELOC_RL78_LO16:
664 case BFD_RELOC_RL78_HI16:
667 /* Fixups to assembler generated expressions do not use %hi or %lo. */
669 as_bad (_("%%hi16/%%lo16 only applies to .short or .hword"));
674 case BFD_RELOC_RL78_HI8:
677 /* Fixups to assembler generated expressions do not use %hi or %lo. */
679 as_bad (_("%%hi8 only applies to .byte"));
688 if (exp->X_op == O_subtract && exp->X_op_symbol)
690 if (size != 4 && size != 2 && size != 1)
691 as_bad (_("difference of two symbols only supported with .long, .short, or .byte"));
693 type = BFD_RELOC_RL78_DIFF;
696 fixP = fix_new_exp (frag, where, (int) size, exp, 0, type);
699 /* These are intended to have values larger than the container,
700 since the backend puts only the portion we need in it.
701 However, we don't have a backend-specific reloc for them as
702 they're handled with complex relocations. */
703 case BFD_RELOC_RL78_LO16:
704 case BFD_RELOC_RL78_HI16:
705 case BFD_RELOC_RL78_HI8:
706 fixP->fx_no_overflow = 1;
714 /*----------------------------------------------------------------------*/
715 /* To recap: we estimate everything based on md_estimate_size, then
716 adjust based on rl78_relax_frag. When it all settles, we call
717 md_convert frag to update the bytes. The relaxation types and
718 relocations are in fragP->tc_frag_data, which is a copy of that
721 Our scheme is as follows: fr_fix has the size of the smallest
722 opcode (like BRA.S). We store the number of total bytes we need in
723 fr_subtype. When we're done relaxing, we use fr_subtype and the
724 existing opcode bytes to figure out what actual opcode we need to
725 put in there. If the fixup isn't resolvable now, we use the
728 #define TRACE_RELAX 0
729 #define tprintf if (TRACE_RELAX) printf
742 /* We're looking for these types of relaxations:
744 BT 00110001 sbit0cc1 addr---- (cc is 10 (BF) or 01 (BT))
745 B~T 00110001 sbit0cc1 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
747 BT sfr 00110001 sbit0cc0 sfr----- addr----
748 BT ES: 00010001 00101110 sbit0cc1 addr----
751 B~C 110111cc 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
753 BH 01100001 110c0011 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
754 B~H 01100001 110c0011 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
757 /* Given the opcode bytes at OP, figure out which opcode it is and
758 return the type of opcode. We use this to re-encode the opcode as
759 a different size later. */
762 rl78_opcode_type (char * op)
765 && ((op[1] & 0x0f) == 0x05
766 || (op[1] & 0x0f) == 0x03))
770 && ((op[1] & 0x0f) == 0x04
771 || (op[1] & 0x0f) == 0x02))
776 && ((op[2] & 0x0f) == 0x05
777 || (op[2] & 0x0f) == 0x03))
780 if ((op[0] & 0xfc) == 0xdc)
784 && (op[1] & 0xef) == 0xc3)
790 /* Returns zero if *addrP has the target address. Else returns nonzero
791 if we cannot compute the target address yet. */
794 rl78_frag_fix_value (fragS * fragP,
802 rl78_bytesT * b = fragP->tc_frag_data;
803 expressionS * exp = & b->fixups[which].exp;
805 if (need_diff && exp->X_op != O_subtract)
808 if (exp->X_add_symbol)
810 if (S_FORCE_RELOC (exp->X_add_symbol, 1))
812 if (S_GET_SEGMENT (exp->X_add_symbol) != segment)
814 addr += S_GET_VALUE (exp->X_add_symbol);
817 if (exp->X_op_symbol)
819 if (exp->X_op != O_subtract)
821 if (S_FORCE_RELOC (exp->X_op_symbol, 1))
823 if (S_GET_SEGMENT (exp->X_op_symbol) != segment)
825 addr -= S_GET_VALUE (exp->X_op_symbol);
829 addr += exp->X_add_number;
834 /* Estimate how big the opcode is after this relax pass. The return
835 value is the difference between fr_fix and the actual size. We
836 compute the total size in rl78_relax_frag and store it in fr_subtype,
837 so we only need to subtract fx_fix and return it. */
840 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED, segT segment ATTRIBUTE_UNUSED)
845 /* This is the size of the opcode that's accounted for in fr_fix. */
846 opfixsize = fragP->fr_fix - (fragP->fr_opcode - fragP->fr_literal);
847 /* This is the size of the opcode that isn't. */
848 delta = (fragP->fr_subtype - opfixsize);
850 tprintf (" -> opfixsize %d delta %d\n", opfixsize, delta);
854 /* Given the new addresses for this relax pass, figure out how big
855 each opcode must be. We store the total number of bytes needed in
856 fr_subtype. The return value is the difference between the size
857 after the last pass and the size after this pass, so we use the old
858 fr_subtype to calculate the difference. */
861 rl78_relax_frag (segT segment ATTRIBUTE_UNUSED, fragS * fragP, long stretch)
863 addressT addr0, sym_addr;
866 int oldsize = fragP->fr_subtype;
867 int newsize = oldsize;
871 mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
873 /* If we ever get more than one reloc per opcode, this is the one
877 optype = rl78_opcode_type (fragP->fr_opcode);
878 /* Try to get the target address. */
879 if (rl78_frag_fix_value (fragP, segment, ri, & addr0,
880 fragP->tc_frag_data->relax[ri].type != RL78_RELAX_BRANCH,
883 /* If we don't, we must use the maximum size for the linker. */
884 switch (fragP->tc_frag_data->relax[ri].type)
886 case RL78_RELAX_BRANCH:
909 fragP->fr_subtype = newsize;
910 tprintf (" -> new %d old %d delta %d (external)\n", newsize, oldsize, newsize-oldsize);
911 return newsize - oldsize;
917 switch (fragP->tc_frag_data->relax[ri].type)
919 case RL78_RELAX_BRANCH:
920 disp = (int) addr0 - (int) mypc;
925 if (disp >= -128 && (disp - (oldsize-2)) <= 127)
932 if (disp >= -128 && (disp - (oldsize-3)) <= 127)
938 if (disp >= -128 && (disp - (oldsize-1)) <= 127)
944 if (disp >= -128 && (disp - (oldsize-2)) <= 127)
956 /* This prevents infinite loops in align-heavy sources. */
957 if (newsize < oldsize)
959 if (fragP->tc_frag_data->times_shrank > 10
960 && fragP->tc_frag_data->times_grown > 10)
962 if (fragP->tc_frag_data->times_shrank < 20)
963 fragP->tc_frag_data->times_shrank ++;
965 else if (newsize > oldsize)
967 if (fragP->tc_frag_data->times_grown < 20)
968 fragP->tc_frag_data->times_grown ++;
971 fragP->fr_subtype = newsize;
972 tprintf (" -> new %d old %d delta %d\n", newsize, oldsize, newsize-oldsize);
973 return newsize - oldsize;
976 /* This lets us test for the opcode type and the desired size in a
978 #define OPCODE(type,size) ((type) * 16 + (size))
980 /* Given the opcode stored in fr_opcode and the number of bytes we
981 think we need, encode a new opcode. We stored a pointer to the
982 fixup for this opcode in the tc_frag_data structure. If we can do
983 the fixup here, we change the relocation type to "none" (we test
984 for that in tc_gen_reloc) else we change it to the right type for
985 the new (biggest) opcode. */
988 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED,
989 segT segment ATTRIBUTE_UNUSED,
990 fragS * fragP ATTRIBUTE_UNUSED)
992 rl78_bytesT * rl78b = fragP->tc_frag_data;
993 addressT addr0, mypc;
995 int reloc_type, reloc_adjust;
996 char * op = fragP->fr_opcode;
999 int fi = (rl78b->n_fixups > 1) ? 1 : 0;
1000 fixS * fix = rl78b->fixups[fi].fixP;
1002 /* If we ever get more than one reloc per opcode, this is the one
1006 /* We used a new frag for this opcode, so the opcode address should
1007 be the frag address. */
1008 mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
1009 tprintf("\033[32mmypc: 0x%x\033[0m\n", (int)mypc);
1011 /* Try to get the target address. If we fail here, we just use the
1013 if (rl78_frag_fix_value (fragP, segment, 0, & addr0,
1014 fragP->tc_frag_data->relax[ri].type != RL78_RELAX_BRANCH, 0))
1016 /* We don't know the target address. */
1020 tprintf ("unknown addr ? - %x = ?\n", (int)mypc);
1024 /* We know the target address, and it's in addr0. */
1025 disp = (int) addr0 - (int) mypc;
1026 tprintf ("known addr %x - %x = %d\n", (int)addr0, (int)mypc, disp);
1032 reloc_type = BFD_RELOC_NONE;
1035 switch (fragP->tc_frag_data->relax[ri].type)
1037 case RL78_RELAX_BRANCH:
1038 switch (OPCODE (rl78_opcode_type (fragP->fr_opcode), fragP->fr_subtype))
1041 case OPCODE (OT_bt, 3): /* BT A,$ - no change. */
1046 case OPCODE (OT_bt, 6): /* BT A,$ - long version. */
1048 op[1] ^= 0x06; /* toggle conditional. */
1049 op[2] = 3; /* displacement over long branch. */
1051 op[3] = 0xEE; /* BR $!addr20 */
1052 op[4] = disp & 0xff;
1054 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1058 case OPCODE (OT_bt_sfr, 4): /* BT PSW,$ - no change. */
1063 case OPCODE (OT_bt_sfr, 7): /* BT PSW,$ - long version. */
1065 op[1] ^= 0x06; /* toggle conditional. */
1066 op[3] = 3; /* displacement over long branch. */
1068 op[4] = 0xEE; /* BR $!addr20 */
1069 op[5] = disp & 0xff;
1071 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1075 case OPCODE (OT_bt_es, 4): /* BT ES:[HL],$ - no change. */
1080 case OPCODE (OT_bt_es, 7): /* BT PSW,$ - long version. */
1082 op[2] ^= 0x06; /* toggle conditional. */
1083 op[3] = 3; /* displacement over long branch. */
1085 op[4] = 0xEE; /* BR $!addr20 */
1086 op[5] = disp & 0xff;
1088 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1092 case OPCODE (OT_bc, 2): /* BC $ - no change. */
1097 case OPCODE (OT_bc, 5): /* BC $ - long version. */
1099 op[0] ^= 0x02; /* toggle conditional. */
1102 op[2] = 0xEE; /* BR $!addr20 */
1103 op[3] = disp & 0xff;
1105 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1109 case OPCODE (OT_bh, 3): /* BH $ - no change. */
1114 case OPCODE (OT_bh, 6): /* BC $ - long version. */
1116 op[1] ^= 0x10; /* toggle conditional. */
1119 op[3] = 0xEE; /* BR $!addr20 */
1120 op[4] = disp & 0xff;
1122 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1127 fprintf(stderr, "Missed case %d %d at 0x%lx\n",
1128 rl78_opcode_type (fragP->fr_opcode), fragP->fr_subtype, mypc);
1135 if (rl78b->n_fixups)
1137 reloc_type = fix->fx_r_type;
1143 if (rl78b->n_fixups)
1146 fix->fx_r_type = reloc_type;
1147 fix->fx_where += reloc_adjust;
1150 case BFD_RELOC_NONE:
1156 case BFD_RELOC_16_PCREL:
1162 fragP->fr_fix = fragP->fr_subtype + (fragP->fr_opcode - fragP->fr_literal);
1163 tprintf ("fragP->fr_fix now %ld (%d + (%p - %p)\n", (long) fragP->fr_fix,
1164 fragP->fr_subtype, fragP->fr_opcode, fragP->fr_literal);
1167 tprintf ("compare 0x%lx vs 0x%lx - 0x%lx = 0x%lx (%p)\n",
1168 (long)fragP->fr_fix,
1169 (long)fragP->fr_next->fr_address, (long)fragP->fr_address,
1170 (long)(fragP->fr_next->fr_address - fragP->fr_address),
1173 if (fragP->fr_next != NULL
1174 && ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
1176 as_bad (_("bad frag at %p : fix %ld addr %ld %ld \n"), fragP,
1177 (long) fragP->fr_fix,
1178 (long) fragP->fr_address, (long) fragP->fr_next->fr_address);
1181 /* End of relaxation code.
1182 ----------------------------------------------------------------------*/
1186 tc_gen_reloc (asection * seg ATTRIBUTE_UNUSED, fixS * fixp)
1188 static arelent * reloc[8];
1191 if (fixp->fx_r_type == BFD_RELOC_NONE)
1198 && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
1200 fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
1201 fixp->fx_subsy = NULL;
1204 reloc[0] = (arelent *) xmalloc (sizeof (arelent));
1205 reloc[0]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
1206 * reloc[0]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1207 reloc[0]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1208 reloc[0]->addend = fixp->fx_offset;
1210 if (fixp->fx_r_type == BFD_RELOC_RL78_32_OP
1213 fixp->fx_r_type = BFD_RELOC_RL78_DIFF;
1216 #define OPX(REL,SYM,ADD) \
1217 reloc[rp] = (arelent *) xmalloc (sizeof (arelent)); \
1218 reloc[rp]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); \
1219 reloc[rp]->howto = bfd_reloc_type_lookup (stdoutput, REL); \
1220 reloc[rp]->addend = ADD; \
1221 * reloc[rp]->sym_ptr_ptr = SYM; \
1222 reloc[rp]->address = fixp->fx_frag->fr_address + fixp->fx_where; \
1224 #define OPSYM(SYM) OPX(BFD_RELOC_RL78_SYM, SYM, 0)
1225 #define OPIMM(IMM) OPX(BFD_RELOC_RL78_SYM, abs_symbol.bsym, IMM)
1226 #define OP(OP) OPX(BFD_RELOC_RL78_##OP, *reloc[0]->sym_ptr_ptr, 0)
1227 #define SYM0() reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RL78_SYM)
1231 /* Certain BFD relocations cannot be translated directly into
1232 a single (non-Red Hat) RL78 relocation, but instead need
1233 multiple RL78 relocations - handle them here. */
1234 switch (fixp->fx_r_type)
1236 case BFD_RELOC_RL78_DIFF:
1238 OPSYM (symbol_get_bfdsym (fixp->fx_subsy));
1241 switch (fixp->fx_size)
1255 case BFD_RELOC_RL78_NEG32:
1261 case BFD_RELOC_RL78_CODE:
1262 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RL78_16U);
1266 case BFD_RELOC_RL78_LO16:
1273 case BFD_RELOC_RL78_HI16:
1280 case BFD_RELOC_RL78_HI8:
1290 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
1299 rl78_validate_fix_sub (struct fix * f)
1301 /* We permit the subtraction of two symbols in a few cases. */
1302 /* mov #sym1-sym2, R3 */
1303 if (f->fx_r_type == BFD_RELOC_RL78_32_OP)
1305 /* .long sym1-sym2 */
1306 if (f->fx_r_type == BFD_RELOC_RL78_DIFF
1308 && (f->fx_size == 4 || f->fx_size == 2 || f->fx_size == 1))
1314 md_pcrel_from_section (fixS * fixP, segT sec)
1318 if (fixP->fx_addsy != NULL
1319 && (! S_IS_DEFINED (fixP->fx_addsy)
1320 || S_GET_SEGMENT (fixP->fx_addsy) != sec))
1321 /* The symbol is undefined (or is defined but not in this section).
1322 Let the linker figure it out. */
1325 rv = fixP->fx_frag->fr_address + fixP->fx_where;
1326 switch (fixP->fx_r_type)
1328 case BFD_RELOC_8_PCREL:
1331 case BFD_RELOC_16_PCREL:
1341 md_apply_fix (struct fix * f ATTRIBUTE_UNUSED,
1342 valueT * t ATTRIBUTE_UNUSED,
1343 segT s ATTRIBUTE_UNUSED)
1348 if (f->fx_addsy && S_FORCE_RELOC (f->fx_addsy, 1))
1350 if (f->fx_subsy && S_FORCE_RELOC (f->fx_subsy, 1))
1353 op = f->fx_frag->fr_literal + f->fx_where;
1354 val = (unsigned long) * t;
1356 switch (f->fx_r_type)
1358 case BFD_RELOC_NONE:
1361 case BFD_RELOC_RL78_RELAX:
1365 case BFD_RELOC_8_PCREL:
1366 if ((long)val < -128 || (long)val > 127)
1367 as_bad_where (f->fx_file, f->fx_line,
1368 _("value of %ld too large for 8-bit branch"),
1375 case BFD_RELOC_16_PCREL:
1376 if ((long)val < -32768 || (long)val > 32767)
1377 as_bad_where (f->fx_file, f->fx_line,
1378 _("value of %ld too large for 16-bit branch"),
1382 case BFD_RELOC_RL78_CODE:
1400 case BFD_RELOC_RL78_DIFF:
1410 case BFD_RELOC_RL78_HI8:
1415 case BFD_RELOC_RL78_HI16:
1421 case BFD_RELOC_RL78_LO16:
1427 as_bad (_("Unknown reloc in md_apply_fix: %s"),
1428 bfd_get_reloc_code_name (f->fx_r_type));
1432 if (f->fx_addsy == NULL)
1437 md_section_align (segT segment, valueT size)
1439 int align = bfd_get_section_alignment (stdoutput, segment);
1440 return ((size + (1 << align) - 1) & (-1 << align));