1 /* tc-rl78.c -- Assembler for the Renesas RL78
2 Copyright (C) 2011-2014 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"
24 #include "safe-ctype.h"
25 #include "dwarf2dbg.h"
27 #include "elf/common.h"
29 #include "rl78-defs.h"
30 #include "filenames.h"
35 const char comment_chars
[] = ";";
36 /* Note that input_file.c hand checks for '#' at the beginning of the
37 first line of the input file. This is because the compiler outputs
38 #NO_APP at the beginning of its output. */
39 const char line_comment_chars
[] = "#";
40 /* Use something that isn't going to be needed by any expressions or
42 const char line_separator_chars
[] = "@";
44 const char EXP_CHARS
[] = "eE";
45 const char FLT_CHARS
[] = "dD";
47 /* ELF flags to set in the output file header. */
48 static int elf_flags
= 0;
50 /*------------------------------------------------------------------*/
52 char * rl78_lex_start
;
55 typedef struct rl78_bytesT
68 char type
; /* RL78REL_*. */
81 fixS
*link_relax_fixP
;
86 static rl78_bytesT rl78_bytes
;
89 rl78_relax (int type
, int pos
)
91 rl78_bytes
.relax
[rl78_bytes
.n_relax
].type
= type
;
92 rl78_bytes
.relax
[rl78_bytes
.n_relax
].field_pos
= pos
;
93 rl78_bytes
.relax
[rl78_bytes
.n_relax
].val_ofs
= rl78_bytes
.n_base
+ rl78_bytes
.n_ops
;
94 rl78_bytes
.n_relax
++;
98 rl78_linkrelax_addr16 (void)
100 rl78_bytes
.link_relax
|= RL78_RELAXA_ADDR16
;
104 rl78_linkrelax_branch (void)
106 rl78_bytes
.link_relax
|= RL78_RELAXA_BRA
;
110 rl78_fixup (expressionS exp
, int offsetbits
, int nbits
, int type
)
112 rl78_bytes
.fixups
[rl78_bytes
.n_fixups
].exp
= exp
;
113 rl78_bytes
.fixups
[rl78_bytes
.n_fixups
].offset
= offsetbits
;
114 rl78_bytes
.fixups
[rl78_bytes
.n_fixups
].nbits
= nbits
;
115 rl78_bytes
.fixups
[rl78_bytes
.n_fixups
].type
= type
;
116 rl78_bytes
.fixups
[rl78_bytes
.n_fixups
].reloc
= exp
.X_md
;
117 rl78_bytes
.n_fixups
++;
120 #define rl78_field_fixup(exp, offset, nbits, type) \
121 rl78_fixup (exp, offset + 8 * rl78_bytes.n_prefix), nbits, type)
123 #define rl78_op_fixup(exp, offset, nbits, type) \
124 rl78_fixup (exp, offset + 8 * (rl78_bytes.n_prefix + rl78_bytes.n_base), nbits, type)
129 rl78_bytes
.prefix
[0] = p
;
130 rl78_bytes
.n_prefix
= 1;
136 return rl78_bytes
.n_prefix
;
142 rl78_bytes
.base
[0] = b1
;
143 rl78_bytes
.n_base
= 1;
147 rl78_base2 (int b1
, int b2
)
149 rl78_bytes
.base
[0] = b1
;
150 rl78_bytes
.base
[1] = b2
;
151 rl78_bytes
.n_base
= 2;
155 rl78_base3 (int b1
, int b2
, int b3
)
157 rl78_bytes
.base
[0] = b1
;
158 rl78_bytes
.base
[1] = b2
;
159 rl78_bytes
.base
[2] = b3
;
160 rl78_bytes
.n_base
= 3;
164 rl78_base4 (int b1
, int b2
, int b3
, int b4
)
166 rl78_bytes
.base
[0] = b1
;
167 rl78_bytes
.base
[1] = b2
;
168 rl78_bytes
.base
[2] = b3
;
169 rl78_bytes
.base
[3] = b4
;
170 rl78_bytes
.n_base
= 4;
173 #define F_PRECISION 2
176 rl78_op (expressionS exp
, int nbytes
, int type
)
180 if ((exp
.X_op
== O_constant
|| exp
.X_op
== O_big
)
181 && type
!= RL78REL_PCREL
)
183 if (exp
.X_op
== O_big
&& exp
.X_add_number
<= 0)
186 char * ip
= rl78_bytes
.ops
+ rl78_bytes
.n_ops
;
188 gen_to_words (w
, F_PRECISION
, 8);
193 rl78_bytes
.n_ops
+= 4;
197 v
= exp
.X_add_number
;
200 rl78_bytes
.ops
[rl78_bytes
.n_ops
++] =v
& 0xff;
209 && exp
.X_md
== BFD_RELOC_RL78_CODE
)
213 && (exp
.X_md
== BFD_RELOC_RL78_LO16
214 || exp
.X_md
== BFD_RELOC_RL78_HI16
))
215 as_bad (_("16-bit relocation used in 8-bit operand"));
218 && exp
.X_md
== BFD_RELOC_RL78_HI8
)
219 as_bad (_("8-bit relocation used in 16-bit operand"));
221 rl78_op_fixup (exp
, rl78_bytes
.n_ops
* 8, nbytes
* 8, type
);
222 memset (rl78_bytes
.ops
+ rl78_bytes
.n_ops
, 0, nbytes
);
223 rl78_bytes
.n_ops
+= nbytes
;
227 /* This gets complicated when the field spans bytes, because fields
228 are numbered from the MSB of the first byte as zero, and bits are
229 stored LSB towards the LSB of the byte. Thus, a simple four-bit
230 insertion of 12 at position 4 of 0x00 yields: 0x0b. A three-bit
231 insertion of b'MXL at position 7 is like this:
233 - - - - - - - - - - - - - - - -
237 rl78_field (int val
, int pos
, int sz
)
244 if (val
< 0 || val
>= (1 << sz
))
245 as_bad (_("Value %d doesn't fit in unsigned %d-bit field"), val
, sz
);
250 if (val
< -(1 << (sz
- 1)) || val
>= (1 << (sz
- 1)))
251 as_bad (_("Value %d doesn't fit in signed %d-bit field"), val
, sz
);
254 /* This code points at 'M' in the above example. */
258 while (bitp
+ sz
> 8)
263 svalm
= val
>> (sz
- ssz
);
264 svalm
= svalm
& ((1 << ssz
) - 1);
265 svalm
= svalm
<< (8 - bitp
- ssz
);
266 gas_assert (bytep
< rl78_bytes
.n_base
);
267 rl78_bytes
.base
[bytep
] |= svalm
;
273 valm
= val
& ((1 << sz
) - 1);
274 valm
= valm
<< (8 - bitp
- sz
);
275 gas_assert (bytep
< rl78_bytes
.n_base
);
276 rl78_bytes
.base
[bytep
] |= valm
;
279 /*------------------------------------------------------------------*/
283 OPTION_RELAX
= OPTION_MD_BASE
,
287 #define RL78_SHORTOPTS ""
288 const char * md_shortopts
= RL78_SHORTOPTS
;
290 /* Assembler options. */
291 struct option md_longopts
[] =
293 {"relax", no_argument
, NULL
, OPTION_RELAX
},
294 {"mg10", no_argument
, NULL
, OPTION_G10
},
295 {NULL
, no_argument
, NULL
, 0}
297 size_t md_longopts_size
= sizeof (md_longopts
);
300 md_parse_option (int c
, char * arg ATTRIBUTE_UNUSED
)
309 elf_flags
|= E_FLAG_RL78_G10
;
316 md_show_usage (FILE * stream ATTRIBUTE_UNUSED
)
322 s_bss (int ignore ATTRIBUTE_UNUSED
)
326 temp
= get_absolute_expression ();
327 subseg_set (bss_section
, (subsegT
) temp
);
328 demand_empty_rest_of_line ();
331 /* The target specific pseudo-ops which we support. */
332 const pseudo_typeS md_pseudo_table
[] =
334 /* Our "standard" pseudos. */
335 { "double", float_cons
, 'd' },
337 { "3byte", cons
, 3 },
341 /* End of list marker. */
355 /* Set the ELF specific flags. */
357 rl78_elf_final_processing (void)
359 elf_elfheader (stdoutput
)->e_flags
|= elf_flags
;
362 /* Write a value out to the object file, using the appropriate endianness. */
364 md_number_to_chars (char * buf
, valueT val
, int n
)
366 number_to_chars_littleendian (buf
, val
, n
);
370 require_end_of_expr (char *fname
)
372 while (* input_line_pointer
== ' '
373 || * input_line_pointer
== '\t')
374 input_line_pointer
++;
376 if (! * input_line_pointer
377 || strchr ("\n\r,", * input_line_pointer
)
378 || strchr (comment_chars
, * input_line_pointer
)
379 || strchr (line_comment_chars
, * input_line_pointer
)
380 || strchr (line_separator_chars
, * input_line_pointer
))
383 as_bad (_("%%%s() must be outermost term in expression"), fname
);
393 { "code", BFD_RELOC_RL78_CODE
},
394 { "lo16", BFD_RELOC_RL78_LO16
},
395 { "hi16", BFD_RELOC_RL78_HI16
},
396 { "hi8", BFD_RELOC_RL78_HI8
},
401 md_operand (expressionS
* exp ATTRIBUTE_UNUSED
)
406 for (i
= 0; reloc_functions
[i
].fname
; i
++)
408 int flen
= strlen (reloc_functions
[i
].fname
);
410 if (input_line_pointer
[0] == '%'
411 && strncasecmp (input_line_pointer
+ 1, reloc_functions
[i
].fname
, flen
) == 0
412 && input_line_pointer
[flen
+ 1] == '(')
414 reloc
= reloc_functions
[i
].reloc
;
415 input_line_pointer
+= flen
+ 2;
423 if (* input_line_pointer
== ')')
424 input_line_pointer
++;
428 require_end_of_expr (reloc_functions
[i
].fname
);
432 rl78_frag_init (fragS
* fragP
)
434 if (rl78_bytes
.n_relax
|| rl78_bytes
.link_relax
)
436 fragP
->tc_frag_data
= malloc (sizeof (rl78_bytesT
));
437 memcpy (fragP
->tc_frag_data
, & rl78_bytes
, sizeof (rl78_bytesT
));
440 fragP
->tc_frag_data
= 0;
443 /* When relaxing, we need to output a reloc for any .align directive
444 so that we can retain this alignment as we adjust opcode sizes. */
446 rl78_handle_align (fragS
* frag
)
449 && (frag
->fr_type
== rs_align
450 || frag
->fr_type
== rs_align_code
)
451 && frag
->fr_address
+ frag
->fr_fix
> 0
452 && frag
->fr_offset
> 0
453 && now_seg
!= bss_section
)
455 fix_new (frag
, frag
->fr_fix
, 0,
456 &abs_symbol
, RL78_RELAXA_ALIGN
+ frag
->fr_offset
,
457 0, BFD_RELOC_RL78_RELAX
);
458 /* For the purposes of relaxation, this relocation is attached
459 to the byte *after* the alignment - i.e. the byte that must
461 fix_new (frag
->fr_next
, 0, 0,
462 &abs_symbol
, RL78_RELAXA_ELIGN
+ frag
->fr_offset
,
463 0, BFD_RELOC_RL78_RELAX
);
468 md_atof (int type
, char * litP
, int * sizeP
)
470 return ieee_md_atof (type
, litP
, sizeP
, target_big_endian
);
474 md_undefined_symbol (char * name ATTRIBUTE_UNUSED
)
479 #define APPEND(B, N_B) \
480 if (rl78_bytes.N_B) \
482 memcpy (bytes + idx, rl78_bytes.B, rl78_bytes.N_B); \
483 idx += rl78_bytes.N_B; \
488 md_assemble (char * str
)
491 fragS
* frag_then
= frag_now
;
497 /*printf("\033[32mASM: %s\033[0m\n", str);*/
499 dwarf2_emit_insn (0);
501 memset (& rl78_bytes
, 0, sizeof (rl78_bytes
));
503 rl78_lex_init (str
, str
+ strlen (str
));
507 /* This simplifies the relaxation code. */
508 if (rl78_bytes
.n_relax
|| rl78_bytes
.link_relax
)
510 int olen
= rl78_bytes
.n_prefix
+ rl78_bytes
.n_base
+ rl78_bytes
.n_ops
;
511 /* We do it this way because we want the frag to have the
512 rl78_bytes in it, which we initialize above. The extra bytes
514 bytes
= frag_more (olen
+ 3);
515 frag_then
= frag_now
;
516 frag_variant (rs_machine_dependent
,
517 olen
/* max_chars */,
523 frag_then
->fr_opcode
= bytes
;
524 frag_then
->fr_fix
= olen
+ (bytes
- frag_then
->fr_literal
);
525 frag_then
->fr_subtype
= olen
;
526 frag_then
->fr_var
= 0;
530 bytes
= frag_more (rl78_bytes
.n_prefix
+ rl78_bytes
.n_base
+ rl78_bytes
.n_ops
);
531 frag_then
= frag_now
;
534 APPEND (prefix
, n_prefix
);
535 APPEND (base
, n_base
);
538 if (rl78_bytes
.link_relax
)
542 f
= fix_new (frag_then
,
543 (char *) bytes
- frag_then
->fr_literal
,
546 rl78_bytes
.link_relax
| rl78_bytes
.n_fixups
,
548 BFD_RELOC_RL78_RELAX
);
549 frag_then
->tc_frag_data
->link_relax_fixP
= f
;
552 for (i
= 0; i
< rl78_bytes
.n_fixups
; i
++)
554 /* index: [nbytes][type] */
555 static int reloc_map
[5][4] =
558 { BFD_RELOC_8
, BFD_RELOC_8_PCREL
},
559 { BFD_RELOC_16
, BFD_RELOC_16_PCREL
},
560 { BFD_RELOC_24
, BFD_RELOC_24_PCREL
},
561 { BFD_RELOC_32
, BFD_RELOC_32_PCREL
},
565 idx
= rl78_bytes
.fixups
[i
].offset
/ 8;
566 rel
= reloc_map
[rl78_bytes
.fixups
[i
].nbits
/ 8][(int) rl78_bytes
.fixups
[i
].type
];
568 if (rl78_bytes
.fixups
[i
].reloc
)
569 rel
= rl78_bytes
.fixups
[i
].reloc
;
571 if (frag_then
->tc_frag_data
)
572 exp
= & frag_then
->tc_frag_data
->fixups
[i
].exp
;
574 exp
= & rl78_bytes
.fixups
[i
].exp
;
576 f
= fix_new_exp (frag_then
,
577 (char *) bytes
+ idx
- frag_then
->fr_literal
,
578 rl78_bytes
.fixups
[i
].nbits
/ 8,
580 rl78_bytes
.fixups
[i
].type
== RL78REL_PCREL
? 1 : 0,
582 if (frag_then
->tc_frag_data
)
583 frag_then
->tc_frag_data
->fixups
[i
].fixP
= f
;
588 rl78_cons_fix_new (fragS
* frag
,
593 bfd_reloc_code_real_type type
;
611 as_bad (_("unsupported constant size %d\n"), size
);
617 case BFD_RELOC_RL78_CODE
:
621 case BFD_RELOC_RL78_LO16
:
622 case BFD_RELOC_RL78_HI16
:
624 as_bad (_("%%hi16/%%lo16 only applies to .short or .hword"));
627 case BFD_RELOC_RL78_HI8
:
629 as_bad (_("%%hi8 only applies to .byte"));
636 if (exp
->X_op
== O_subtract
&& exp
->X_op_symbol
)
638 if (size
!= 4 && size
!= 2 && size
!= 1)
639 as_bad (_("difference of two symbols only supported with .long, .short, or .byte"));
641 type
= BFD_RELOC_RL78_DIFF
;
644 fixP
= fix_new_exp (frag
, where
, (int) size
, exp
, 0, type
);
647 /* These are intended to have values larger than the container,
648 since the backend puts only the portion we need in it.
649 However, we don't have a backend-specific reloc for them as
650 they're handled with complex relocations. */
651 case BFD_RELOC_RL78_LO16
:
652 case BFD_RELOC_RL78_HI16
:
653 case BFD_RELOC_RL78_HI8
:
654 fixP
->fx_no_overflow
= 1;
662 /*----------------------------------------------------------------------*/
663 /* To recap: we estimate everything based on md_estimate_size, then
664 adjust based on rl78_relax_frag. When it all settles, we call
665 md_convert frag to update the bytes. The relaxation types and
666 relocations are in fragP->tc_frag_data, which is a copy of that
669 Our scheme is as follows: fr_fix has the size of the smallest
670 opcode (like BRA.S). We store the number of total bytes we need in
671 fr_subtype. When we're done relaxing, we use fr_subtype and the
672 existing opcode bytes to figure out what actual opcode we need to
673 put in there. If the fixup isn't resolvable now, we use the
676 #define TRACE_RELAX 0
677 #define tprintf if (TRACE_RELAX) printf
690 /* We're looking for these types of relaxations:
692 BT 00110001 sbit0cc1 addr---- (cc is 10 (BF) or 01 (BT))
693 B~T 00110001 sbit0cc1 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
695 BT sfr 00110001 sbit0cc0 sfr----- addr----
696 BT ES: 00010001 00101110 sbit0cc1 addr----
699 B~C 110111cc 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
701 BH 01100001 110c0011 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
702 B~H 01100001 110c0011 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
705 /* Given the opcode bytes at OP, figure out which opcode it is and
706 return the type of opcode. We use this to re-encode the opcode as
707 a different size later. */
710 rl78_opcode_type (char * op
)
713 && ((op
[1] & 0x0f) == 0x05
714 || (op
[1] & 0x0f) == 0x03))
718 && ((op
[1] & 0x0f) == 0x04
719 || (op
[1] & 0x0f) == 0x02))
724 && ((op
[2] & 0x0f) == 0x05
725 || (op
[2] & 0x0f) == 0x03))
728 if ((op
[0] & 0xfc) == 0xdc)
732 && (op
[1] & 0xef) == 0xc3)
738 /* Returns zero if *addrP has the target address. Else returns nonzero
739 if we cannot compute the target address yet. */
742 rl78_frag_fix_value (fragS
* fragP
,
750 rl78_bytesT
* b
= fragP
->tc_frag_data
;
751 expressionS
* exp
= & b
->fixups
[which
].exp
;
753 if (need_diff
&& exp
->X_op
!= O_subtract
)
756 if (exp
->X_add_symbol
)
758 if (S_FORCE_RELOC (exp
->X_add_symbol
, 1))
760 if (S_GET_SEGMENT (exp
->X_add_symbol
) != segment
)
762 addr
+= S_GET_VALUE (exp
->X_add_symbol
);
765 if (exp
->X_op_symbol
)
767 if (exp
->X_op
!= O_subtract
)
769 if (S_FORCE_RELOC (exp
->X_op_symbol
, 1))
771 if (S_GET_SEGMENT (exp
->X_op_symbol
) != segment
)
773 addr
-= S_GET_VALUE (exp
->X_op_symbol
);
777 addr
+= exp
->X_add_number
;
782 /* Estimate how big the opcode is after this relax pass. The return
783 value is the difference between fr_fix and the actual size. We
784 compute the total size in rl78_relax_frag and store it in fr_subtype,
785 sowe only need to subtract fx_fix and return it. */
788 md_estimate_size_before_relax (fragS
* fragP ATTRIBUTE_UNUSED
, segT segment ATTRIBUTE_UNUSED
)
793 /* This is the size of the opcode that's accounted for in fr_fix. */
794 opfixsize
= fragP
->fr_fix
- (fragP
->fr_opcode
- fragP
->fr_literal
);
795 /* This is the size of the opcode that isn't. */
796 delta
= (fragP
->fr_subtype
- opfixsize
);
798 tprintf (" -> opfixsize %d delta %d\n", opfixsize
, delta
);
802 /* Given the new addresses for this relax pass, figure out how big
803 each opcode must be. We store the total number of bytes needed in
804 fr_subtype. The return value is the difference between the size
805 after the last pass and the size after this pass, so we use the old
806 fr_subtype to calculate the difference. */
809 rl78_relax_frag (segT segment ATTRIBUTE_UNUSED
, fragS
* fragP
, long stretch
)
811 addressT addr0
, sym_addr
;
814 int oldsize
= fragP
->fr_subtype
;
815 int newsize
= oldsize
;
819 mypc
= fragP
->fr_address
+ (fragP
->fr_opcode
- fragP
->fr_literal
);
821 /* If we ever get more than one reloc per opcode, this is the one
825 optype
= rl78_opcode_type (fragP
->fr_opcode
);
826 /* Try to get the target address. */
827 if (rl78_frag_fix_value (fragP
, segment
, ri
, & addr0
,
828 fragP
->tc_frag_data
->relax
[ri
].type
!= RL78_RELAX_BRANCH
,
831 /* If we don't, we must use the maximum size for the linker. */
832 switch (fragP
->tc_frag_data
->relax
[ri
].type
)
834 case RL78_RELAX_BRANCH
:
857 fragP
->fr_subtype
= newsize
;
858 tprintf (" -> new %d old %d delta %d (external)\n", newsize
, oldsize
, newsize
-oldsize
);
859 return newsize
- oldsize
;
865 switch (fragP
->tc_frag_data
->relax
[ri
].type
)
867 case RL78_RELAX_BRANCH
:
868 disp
= (int) addr0
- (int) mypc
;
873 if (disp
>= -128 && (disp
- (oldsize
-2)) <= 127)
880 if (disp
>= -128 && (disp
- (oldsize
-3)) <= 127)
886 if (disp
>= -128 && (disp
- (oldsize
-1)) <= 127)
892 if (disp
>= -128 && (disp
- (oldsize
-2)) <= 127)
904 /* This prevents infinite loops in align-heavy sources. */
905 if (newsize
< oldsize
)
907 if (fragP
->tc_frag_data
->times_shrank
> 10
908 && fragP
->tc_frag_data
->times_grown
> 10)
910 if (fragP
->tc_frag_data
->times_shrank
< 20)
911 fragP
->tc_frag_data
->times_shrank
++;
913 else if (newsize
> oldsize
)
915 if (fragP
->tc_frag_data
->times_grown
< 20)
916 fragP
->tc_frag_data
->times_grown
++;
919 fragP
->fr_subtype
= newsize
;
920 tprintf (" -> new %d old %d delta %d\n", newsize
, oldsize
, newsize
-oldsize
);
921 return newsize
- oldsize
;
924 /* This lets us test for the opcode type and the desired size in a
926 #define OPCODE(type,size) ((type) * 16 + (size))
928 /* Given the opcode stored in fr_opcode and the number of bytes we
929 think we need, encode a new opcode. We stored a pointer to the
930 fixup for this opcode in the tc_frag_data structure. If we can do
931 the fixup here, we change the relocation type to "none" (we test
932 for that in tc_gen_reloc) else we change it to the right type for
933 the new (biggest) opcode. */
936 md_convert_frag (bfd
* abfd ATTRIBUTE_UNUSED
,
937 segT segment ATTRIBUTE_UNUSED
,
938 fragS
* fragP ATTRIBUTE_UNUSED
)
940 rl78_bytesT
* rl78b
= fragP
->tc_frag_data
;
941 addressT addr0
, mypc
;
943 int reloc_type
, reloc_adjust
;
944 char * op
= fragP
->fr_opcode
;
947 int fi
= (rl78b
->n_fixups
> 1) ? 1 : 0;
948 fixS
* fix
= rl78b
->fixups
[fi
].fixP
;
950 /* If we ever get more than one reloc per opcode, this is the one
954 /* We used a new frag for this opcode, so the opcode address should
955 be the frag address. */
956 mypc
= fragP
->fr_address
+ (fragP
->fr_opcode
- fragP
->fr_literal
);
957 tprintf("\033[32mmypc: 0x%x\033[0m\n", (int)mypc
);
959 /* Try to get the target address. If we fail here, we just use the
961 if (rl78_frag_fix_value (fragP
, segment
, 0, & addr0
,
962 fragP
->tc_frag_data
->relax
[ri
].type
!= RL78_RELAX_BRANCH
, 0))
964 /* We don't know the target address. */
968 tprintf ("unknown addr ? - %x = ?\n", (int)mypc
);
972 /* We know the target address, and it's in addr0. */
973 disp
= (int) addr0
- (int) mypc
;
974 tprintf ("known addr %x - %x = %d\n", (int)addr0
, (int)mypc
, disp
);
980 reloc_type
= BFD_RELOC_NONE
;
983 switch (fragP
->tc_frag_data
->relax
[ri
].type
)
985 case RL78_RELAX_BRANCH
:
986 switch (OPCODE (rl78_opcode_type (fragP
->fr_opcode
), fragP
->fr_subtype
))
989 case OPCODE (OT_bt
, 3): /* BT A,$ - no change. */
994 case OPCODE (OT_bt
, 6): /* BT A,$ - long version. */
996 op
[1] ^= 0x06; /* toggle conditional. */
997 op
[2] = 3; /* displacement over long branch. */
999 op
[3] = 0xEE; /* BR $!addr20 */
1000 op
[4] = disp
& 0xff;
1002 reloc_type
= keep_reloc
? BFD_RELOC_16_PCREL
: BFD_RELOC_NONE
;
1006 case OPCODE (OT_bt_sfr
, 4): /* BT PSW,$ - no change. */
1011 case OPCODE (OT_bt_sfr
, 7): /* BT PSW,$ - long version. */
1013 op
[1] ^= 0x06; /* toggle conditional. */
1014 op
[3] = 3; /* displacement over long branch. */
1016 op
[4] = 0xEE; /* BR $!addr20 */
1017 op
[5] = disp
& 0xff;
1019 reloc_type
= keep_reloc
? BFD_RELOC_16_PCREL
: BFD_RELOC_NONE
;
1023 case OPCODE (OT_bt_es
, 4): /* BT ES:[HL],$ - no change. */
1028 case OPCODE (OT_bt_es
, 7): /* BT PSW,$ - long version. */
1030 op
[2] ^= 0x06; /* toggle conditional. */
1031 op
[3] = 3; /* displacement over long branch. */
1033 op
[4] = 0xEE; /* BR $!addr20 */
1034 op
[5] = disp
& 0xff;
1036 reloc_type
= keep_reloc
? BFD_RELOC_16_PCREL
: BFD_RELOC_NONE
;
1040 case OPCODE (OT_bc
, 2): /* BC $ - no change. */
1045 case OPCODE (OT_bc
, 5): /* BC $ - long version. */
1047 op
[0] ^= 0x02; /* toggle conditional. */
1050 op
[2] = 0xEE; /* BR $!addr20 */
1051 op
[3] = disp
& 0xff;
1053 reloc_type
= keep_reloc
? BFD_RELOC_16_PCREL
: BFD_RELOC_NONE
;
1057 case OPCODE (OT_bh
, 3): /* BH $ - no change. */
1062 case OPCODE (OT_bh
, 6): /* BC $ - long version. */
1064 op
[1] ^= 0x10; /* toggle conditional. */
1067 op
[3] = 0xEE; /* BR $!addr20 */
1068 op
[4] = disp
& 0xff;
1070 reloc_type
= keep_reloc
? BFD_RELOC_16_PCREL
: BFD_RELOC_NONE
;
1075 fprintf(stderr
, "Missed case %d %d at 0x%lx\n",
1076 rl78_opcode_type (fragP
->fr_opcode
), fragP
->fr_subtype
, mypc
);
1083 if (rl78b
->n_fixups
)
1085 reloc_type
= fix
->fx_r_type
;
1091 if (rl78b
->n_fixups
)
1094 fix
->fx_r_type
= reloc_type
;
1095 fix
->fx_where
+= reloc_adjust
;
1098 case BFD_RELOC_NONE
:
1104 case BFD_RELOC_16_PCREL
:
1110 fragP
->fr_fix
= fragP
->fr_subtype
+ (fragP
->fr_opcode
- fragP
->fr_literal
);
1111 tprintf ("fragP->fr_fix now %ld (%d + (%p - %p)\n", (long) fragP
->fr_fix
,
1112 fragP
->fr_subtype
, fragP
->fr_opcode
, fragP
->fr_literal
);
1115 tprintf ("compare 0x%lx vs 0x%lx - 0x%lx = 0x%lx (%p)\n",
1116 (long)fragP
->fr_fix
,
1117 (long)fragP
->fr_next
->fr_address
, (long)fragP
->fr_address
,
1118 (long)(fragP
->fr_next
->fr_address
- fragP
->fr_address
),
1121 if (fragP
->fr_next
!= NULL
1122 && ((offsetT
) (fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1124 as_bad (_("bad frag at %p : fix %ld addr %ld %ld \n"), fragP
,
1125 (long) fragP
->fr_fix
,
1126 (long) fragP
->fr_address
, (long) fragP
->fr_next
->fr_address
);
1129 /* End of relaxation code.
1130 ----------------------------------------------------------------------*/
1134 tc_gen_reloc (asection
* seg ATTRIBUTE_UNUSED
, fixS
* fixp
)
1136 static arelent
* reloc
[8];
1139 if (fixp
->fx_r_type
== BFD_RELOC_NONE
)
1146 && S_GET_SEGMENT (fixp
->fx_subsy
) == absolute_section
)
1148 fixp
->fx_offset
-= S_GET_VALUE (fixp
->fx_subsy
);
1149 fixp
->fx_subsy
= NULL
;
1152 reloc
[0] = (arelent
*) xmalloc (sizeof (arelent
));
1153 reloc
[0]->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
1154 * reloc
[0]->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
1155 reloc
[0]->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1156 reloc
[0]->addend
= fixp
->fx_offset
;
1158 if (fixp
->fx_r_type
== BFD_RELOC_RL78_32_OP
1161 fixp
->fx_r_type
= BFD_RELOC_RL78_DIFF
;
1164 #define OPX(REL,SYM,ADD) \
1165 reloc[rp] = (arelent *) xmalloc (sizeof (arelent)); \
1166 reloc[rp]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); \
1167 reloc[rp]->howto = bfd_reloc_type_lookup (stdoutput, REL); \
1168 reloc[rp]->addend = ADD; \
1169 * reloc[rp]->sym_ptr_ptr = SYM; \
1170 reloc[rp]->address = fixp->fx_frag->fr_address + fixp->fx_where; \
1172 #define OPSYM(SYM) OPX(BFD_RELOC_RL78_SYM, SYM, 0)
1173 #define OPIMM(IMM) OPX(BFD_RELOC_RL78_SYM, abs_symbol.bsym, IMM)
1174 #define OP(OP) OPX(BFD_RELOC_RL78_##OP, *reloc[0]->sym_ptr_ptr, 0)
1175 #define SYM0() reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RL78_SYM)
1179 /* Certain BFD relocations cannot be translated directly into
1180 a single (non-Red Hat) RL78 relocation, but instead need
1181 multiple RL78 relocations - handle them here. */
1182 switch (fixp
->fx_r_type
)
1184 case BFD_RELOC_RL78_DIFF
:
1186 OPSYM (symbol_get_bfdsym (fixp
->fx_subsy
));
1189 switch (fixp
->fx_size
)
1203 case BFD_RELOC_RL78_NEG32
:
1209 case BFD_RELOC_RL78_CODE
:
1210 reloc
[0]->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_RL78_16U
);
1214 case BFD_RELOC_RL78_LO16
:
1221 case BFD_RELOC_RL78_HI16
:
1228 case BFD_RELOC_RL78_HI8
:
1238 reloc
[0]->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
1247 rl78_validate_fix_sub (struct fix
* f
)
1249 /* We permit the subtraction of two symbols in a few cases. */
1250 /* mov #sym1-sym2, R3 */
1251 if (f
->fx_r_type
== BFD_RELOC_RL78_32_OP
)
1253 /* .long sym1-sym2 */
1254 if (f
->fx_r_type
== BFD_RELOC_RL78_DIFF
1256 && (f
->fx_size
== 4 || f
->fx_size
== 2 || f
->fx_size
== 1))
1262 md_pcrel_from_section (fixS
* fixP
, segT sec
)
1266 if (fixP
->fx_addsy
!= NULL
1267 && (! S_IS_DEFINED (fixP
->fx_addsy
)
1268 || S_GET_SEGMENT (fixP
->fx_addsy
) != sec
))
1269 /* The symbol is undefined (or is defined but not in this section).
1270 Let the linker figure it out. */
1273 rv
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
1274 switch (fixP
->fx_r_type
)
1276 case BFD_RELOC_8_PCREL
:
1279 case BFD_RELOC_16_PCREL
:
1289 md_apply_fix (struct fix
* f ATTRIBUTE_UNUSED
,
1290 valueT
* t ATTRIBUTE_UNUSED
,
1291 segT s ATTRIBUTE_UNUSED
)
1296 if (f
->fx_addsy
&& S_FORCE_RELOC (f
->fx_addsy
, 1))
1298 if (f
->fx_subsy
&& S_FORCE_RELOC (f
->fx_subsy
, 1))
1301 op
= f
->fx_frag
->fr_literal
+ f
->fx_where
;
1302 val
= (unsigned long) * t
;
1304 switch (f
->fx_r_type
)
1306 case BFD_RELOC_NONE
:
1309 case BFD_RELOC_RL78_RELAX
:
1313 case BFD_RELOC_8_PCREL
:
1314 if ((long)val
< -128 || (long)val
> 127)
1315 as_bad_where (f
->fx_file
, f
->fx_line
,
1316 _("value of %ld too large for 8-bit branch"),
1323 case BFD_RELOC_16_PCREL
:
1324 if ((long)val
< -32768 || (long)val
> 32767)
1325 as_bad_where (f
->fx_file
, f
->fx_line
,
1326 _("value of %ld too large for 16-bit branch"),
1330 case BFD_RELOC_RL78_CODE
:
1342 case BFD_RELOC_RL78_DIFF
:
1349 case BFD_RELOC_RL78_HI8
:
1354 case BFD_RELOC_RL78_HI16
:
1360 case BFD_RELOC_RL78_LO16
:
1366 as_bad (_("Unknown reloc in md_apply_fix: %s"),
1367 bfd_get_reloc_code_name (f
->fx_r_type
));
1371 if (f
->fx_addsy
== NULL
)
1376 md_section_align (segT segment
, valueT size
)
1378 int align
= bfd_get_section_alignment (stdoutput
, segment
);
1379 return ((size
+ (1 << align
) - 1) & (-1 << align
));