1 /* tc-v850.c -- Assembler code for the NEC V850
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS 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, or (at your option)
12 GAS 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.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street - Fifth Floor,
20 Boston, MA 02110-1301, USA. */
23 #include "safe-ctype.h"
25 #include "opcode/v850.h"
26 #include "dwarf2dbg.h"
28 /* Sign-extend a 16-bit number. */
29 #define SEXT16(x) ((((x) & 0xffff) ^ (~0x7fff)) + 0x8000)
31 /* Temporarily holds the reloc in a cons expression. */
32 static bfd_reloc_code_real_type hold_cons_reloc
= BFD_RELOC_UNUSED
;
34 /* Set to TRUE if we want to be pedantic about signed overflows. */
35 static bfd_boolean warn_signed_overflows
= FALSE
;
36 static bfd_boolean warn_unsigned_overflows
= FALSE
;
38 /* Indicates the target BFD machine number. */
39 static int machine
= -1;
41 /* Indicates the target processor(s) for the assemble. */
42 static int processor_mask
= -1;
44 /* Structure to hold information about predefined registers. */
51 /* Generic assembler global variables which must be defined by all
54 /* Characters which always start a comment. */
55 const char comment_chars
[] = "#";
57 /* Characters which start a comment at the beginning of a line. */
58 const char line_comment_chars
[] = ";#";
60 /* Characters which may be used to separate multiple commands on a
62 const char line_separator_chars
[] = ";";
64 /* Characters which are used to indicate an exponent in a floating
66 const char EXP_CHARS
[] = "eE";
68 /* Characters which mean that a number is a floating point constant,
70 const char FLT_CHARS
[] = "dD";
72 const relax_typeS md_relax_table
[] =
74 /* Conditional branches. */
76 {0x1fffff, -0x200000, 6, 0},
77 /* Unconditional branches. */
79 {0x1fffff, -0x200000, 4, 0},
82 static int v850_relax
= 0;
85 #define MAX_INSN_FIXUPS 5
91 bfd_reloc_code_real_type reloc
;
94 struct v850_fixup fixups
[MAX_INSN_FIXUPS
];
104 struct v850_seg_entry v850_seg_table
[] =
107 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
110 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
},
112 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
},
114 SEC_ALLOC
| SEC_SMALL_DATA
},
120 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_READONLY
| SEC_DATA
121 | SEC_HAS_CONTENTS
| SEC_SMALL_DATA
},
123 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_READONLY
| SEC_DATA
124 | SEC_HAS_CONTENTS
},
126 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
127 | SEC_SMALL_DATA
| SEC_IS_COMMON
},
129 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
132 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
134 { NULL
, ".call_table_data",
135 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
},
136 { NULL
, ".call_table_text",
137 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_READONLY
| SEC_CODE
143 #define SDATA_SECTION 0
144 #define TDATA_SECTION 1
145 #define ZDATA_SECTION 2
146 #define SBSS_SECTION 3
147 #define TBSS_SECTION 4
148 #define ZBSS_SECTION 5
149 #define ROSDATA_SECTION 6
150 #define ROZDATA_SECTION 7
151 #define SCOMMON_SECTION 8
152 #define TCOMMON_SECTION 9
153 #define ZCOMMON_SECTION 10
154 #define CALL_TABLE_DATA_SECTION 11
155 #define CALL_TABLE_TEXT_SECTION 12
156 #define BSS_SECTION 13
159 do_v850_seg (int i
, subsegT sub
)
161 struct v850_seg_entry
*seg
= v850_seg_table
+ i
;
163 obj_elf_section_change_hook ();
166 subseg_set (seg
->s
, sub
);
169 seg
->s
= subseg_new (seg
->name
, sub
);
170 bfd_set_section_flags (stdoutput
, seg
->s
, seg
->flags
);
171 if ((seg
->flags
& SEC_LOAD
) == 0)
172 seg_info (seg
->s
)->bss
= 1;
179 subsegT sub
= get_absolute_expression ();
181 do_v850_seg (i
, sub
);
182 demand_empty_rest_of_line ();
186 v850_offset (int ignore ATTRIBUTE_UNUSED
)
189 int temp
= get_absolute_expression ();
191 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, (symbolS
*)0,
192 (offsetT
) temp
, (char *) 0);
195 demand_empty_rest_of_line ();
198 /* Copied from obj_elf_common() in gas/config/obj-elf.c. */
211 name
= input_line_pointer
;
212 c
= get_symbol_end ();
214 /* Just after name is now '\0'. */
215 p
= input_line_pointer
;
220 if (*input_line_pointer
!= ',')
222 as_bad (_("Expected comma after symbol-name"));
223 ignore_rest_of_line ();
228 input_line_pointer
++;
230 if ((temp
= get_absolute_expression ()) < 0)
232 /* xgettext:c-format */
233 as_bad (_(".COMMon length (%d.) < 0! Ignored."), temp
);
234 ignore_rest_of_line ();
240 symbolP
= symbol_find_or_make (name
);
243 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
245 as_bad (_("Ignoring attempt to re-define symbol"));
246 ignore_rest_of_line ();
250 if (S_GET_VALUE (symbolP
) != 0)
252 if (S_GET_VALUE (symbolP
) != size
)
253 /* xgettext:c-format */
254 as_warn (_("Length of .comm \"%s\" is already %ld. Not changed to %d."),
255 S_GET_NAME (symbolP
), (long) S_GET_VALUE (symbolP
), size
);
258 know (symbol_get_frag (symbolP
) == &zero_address_frag
);
260 if (*input_line_pointer
!= ',')
265 input_line_pointer
++;
269 if (! have_align
|| *input_line_pointer
!= '"')
275 temp
= get_absolute_expression ();
280 as_warn (_("Common alignment negative; 0 assumed"));
284 if (symbol_get_obj (symbolP
)->local
)
293 old_subsec
= now_subseg
;
295 applicable
= bfd_applicable_section_flags (stdoutput
);
297 applicable
&= SEC_ALLOC
;
301 case SCOMMON_SECTION
:
302 do_v850_seg (SBSS_SECTION
, 0);
305 case ZCOMMON_SECTION
:
306 do_v850_seg (ZBSS_SECTION
, 0);
309 case TCOMMON_SECTION
:
310 do_v850_seg (TBSS_SECTION
, 0);
316 /* Convert to a power of 2 alignment. */
317 for (align
= 0; (temp
& 1) == 0; temp
>>= 1, ++align
)
322 as_bad (_("Common alignment not a power of 2"));
323 ignore_rest_of_line ();
330 record_alignment (now_seg
, align
);
333 frag_align (align
, 0, 0);
337 case SCOMMON_SECTION
:
338 if (S_GET_SEGMENT (symbolP
) == v850_seg_table
[SBSS_SECTION
].s
)
339 symbol_get_frag (symbolP
)->fr_symbol
= 0;
342 case ZCOMMON_SECTION
:
343 if (S_GET_SEGMENT (symbolP
) == v850_seg_table
[ZBSS_SECTION
].s
)
344 symbol_get_frag (symbolP
)->fr_symbol
= 0;
347 case TCOMMON_SECTION
:
348 if (S_GET_SEGMENT (symbolP
) == v850_seg_table
[TBSS_SECTION
].s
)
349 symbol_get_frag (symbolP
)->fr_symbol
= 0;
356 symbol_set_frag (symbolP
, frag_now
);
357 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
,
358 (offsetT
) size
, (char *) 0);
360 S_SET_SIZE (symbolP
, size
);
364 case SCOMMON_SECTION
:
365 S_SET_SEGMENT (symbolP
, v850_seg_table
[SBSS_SECTION
].s
);
368 case ZCOMMON_SECTION
:
369 S_SET_SEGMENT (symbolP
, v850_seg_table
[ZBSS_SECTION
].s
);
372 case TCOMMON_SECTION
:
373 S_SET_SEGMENT (symbolP
, v850_seg_table
[TBSS_SECTION
].s
);
380 S_CLEAR_EXTERNAL (symbolP
);
381 obj_elf_section_change_hook ();
382 subseg_set (old_sec
, old_subsec
);
391 old_subsec
= now_subseg
;
393 S_SET_VALUE (symbolP
, (valueT
) size
);
394 S_SET_ALIGN (symbolP
, temp
);
395 S_SET_EXTERNAL (symbolP
);
399 case SCOMMON_SECTION
:
400 case ZCOMMON_SECTION
:
401 case TCOMMON_SECTION
:
402 do_v850_seg (area
, 0);
403 S_SET_SEGMENT (symbolP
, v850_seg_table
[area
].s
);
410 obj_elf_section_change_hook ();
411 subseg_set (old_sec
, old_subsec
);
416 input_line_pointer
++;
418 /* @@ Some use the dot, some don't. Can we get some consistency?? */
419 if (*input_line_pointer
== '.')
420 input_line_pointer
++;
422 /* @@ Some say data, some say bss. */
423 if (strncmp (input_line_pointer
, "bss\"", 4)
424 && strncmp (input_line_pointer
, "data\"", 5))
426 while (*--input_line_pointer
!= '"')
428 input_line_pointer
--;
429 goto bad_common_segment
;
432 while (*input_line_pointer
++ != '"')
435 goto allocate_common
;
438 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
440 demand_empty_rest_of_line ();
445 p
= input_line_pointer
;
446 while (*p
&& *p
!= '\n')
450 as_bad (_("bad .common segment %s"), input_line_pointer
+ 1);
452 input_line_pointer
= p
;
453 ignore_rest_of_line ();
459 set_machine (int number
)
462 bfd_set_arch_mach (stdoutput
, TARGET_ARCH
, machine
);
466 case 0: processor_mask
= PROCESSOR_V850
; break;
467 case bfd_mach_v850e
: processor_mask
= PROCESSOR_V850E
; break;
468 case bfd_mach_v850e1
: processor_mask
= PROCESSOR_V850E
; break;
473 v850_longcode (int type
)
480 as_warn (".longcall pseudo-op seen when not relaxing");
482 as_warn (".longjump pseudo-op seen when not relaxing");
487 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
489 as_bad ("bad .longcall format");
490 ignore_rest_of_line ();
496 fix_new_exp (frag_now
, frag_now_fix (), 4, & ex
, 1,
497 BFD_RELOC_V850_LONGCALL
);
499 fix_new_exp (frag_now
, frag_now_fix (), 4, & ex
, 1,
500 BFD_RELOC_V850_LONGJUMP
);
502 demand_empty_rest_of_line ();
505 /* The target specific pseudo-ops which we support. */
506 const pseudo_typeS md_pseudo_table
[] =
508 { "sdata", v850_seg
, SDATA_SECTION
},
509 { "tdata", v850_seg
, TDATA_SECTION
},
510 { "zdata", v850_seg
, ZDATA_SECTION
},
511 { "sbss", v850_seg
, SBSS_SECTION
},
512 { "tbss", v850_seg
, TBSS_SECTION
},
513 { "zbss", v850_seg
, ZBSS_SECTION
},
514 { "rosdata", v850_seg
, ROSDATA_SECTION
},
515 { "rozdata", v850_seg
, ROZDATA_SECTION
},
516 { "bss", v850_seg
, BSS_SECTION
},
517 { "offset", v850_offset
, 0 },
519 { "zcomm", v850_comm
, ZCOMMON_SECTION
},
520 { "scomm", v850_comm
, SCOMMON_SECTION
},
521 { "tcomm", v850_comm
, TCOMMON_SECTION
},
522 { "v850", set_machine
, 0 },
523 { "call_table_data", v850_seg
, CALL_TABLE_DATA_SECTION
},
524 { "call_table_text", v850_seg
, CALL_TABLE_TEXT_SECTION
},
525 { "v850e", set_machine
, bfd_mach_v850e
},
526 { "v850e1", set_machine
, bfd_mach_v850e1
},
527 { "longcall", v850_longcode
, 1 },
528 { "longjump", v850_longcode
, 2 },
532 /* Opcode hash table. */
533 static struct hash_control
*v850_hash
;
535 /* This table is sorted. Suitable for searching by a binary search. */
536 static const struct reg_name pre_defined_registers
[] =
538 { "ep", 30 }, /* ep - element ptr. */
539 { "gp", 4 }, /* gp - global ptr. */
540 { "hp", 2 }, /* hp - handler stack ptr. */
541 { "lp", 31 }, /* lp - link ptr. */
574 { "sp", 3 }, /* sp - stack ptr. */
575 { "tp", 5 }, /* tp - text ptr. */
579 #define REG_NAME_CNT \
580 (sizeof (pre_defined_registers) / sizeof (struct reg_name))
582 static const struct reg_name system_registers
[] =
604 #define SYSREG_NAME_CNT \
605 (sizeof (system_registers) / sizeof (struct reg_name))
607 static const struct reg_name system_list_registers
[] =
613 #define SYSREGLIST_NAME_CNT \
614 (sizeof (system_list_registers) / sizeof (struct reg_name))
616 static const struct reg_name cc_names
[] =
642 #define CC_NAME_CNT \
643 (sizeof (cc_names) / sizeof (struct reg_name))
645 /* Do a binary search of the given register table to see if NAME is a
646 valid regiter name. Return the register number from the array on
647 success, or -1 on failure. */
650 reg_name_search (const struct reg_name
*regs
,
653 bfd_boolean accept_numbers
)
655 int middle
, low
, high
;
659 /* If the register name is a symbol, then evaluate it. */
660 if ((symbolP
= symbol_find (name
)) != NULL
)
662 /* If the symbol is an alias for another name then use that.
663 If the symbol is an alias for a number, then return the number. */
664 if (symbol_equated_p (symbolP
))
666 = S_GET_NAME (symbol_get_value_expression (symbolP
)->X_add_symbol
);
667 else if (accept_numbers
)
669 int reg
= S_GET_VALUE (symbolP
);
671 if (reg
>= 0 && reg
<= 31)
675 /* Otherwise drop through and try parsing name normally. */
683 middle
= (low
+ high
) / 2;
684 cmp
= strcasecmp (name
, regs
[middle
].name
);
690 return regs
[middle
].value
;
696 /* Summary of register_name().
698 in: Input_line_pointer points to 1st char of operand.
701 The operand may have been a register: in this case, X_op == O_register,
702 X_add_number is set to the register number, and truth is returned.
703 Input_line_pointer->(next non-blank) char after operand, or is in
704 its original state. */
707 register_name (expressionS
*expressionP
)
714 /* Find the spelling of the operand. */
715 start
= name
= input_line_pointer
;
717 c
= get_symbol_end ();
719 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
,
722 /* Put back the delimiting char. */
723 *input_line_pointer
= c
;
725 /* Look to see if it's in the register table. */
728 expressionP
->X_op
= O_register
;
729 expressionP
->X_add_number
= reg_number
;
731 /* Make the rest nice. */
732 expressionP
->X_add_symbol
= NULL
;
733 expressionP
->X_op_symbol
= NULL
;
739 /* Reset the line as if we had not done anything. */
740 input_line_pointer
= start
;
746 /* Summary of system_register_name().
748 in: INPUT_LINE_POINTER points to 1st char of operand.
749 EXPRESSIONP points to an expression structure to be filled in.
750 ACCEPT_NUMBERS is true iff numerical register names may be used.
751 ACCEPT_LIST_NAMES is true iff the special names PS and SR may be
754 out: An expressionS structure in expressionP.
755 The operand may have been a register: in this case, X_op == O_register,
756 X_add_number is set to the register number, and truth is returned.
757 Input_line_pointer->(next non-blank) char after operand, or is in
758 its original state. */
761 system_register_name (expressionS
*expressionP
,
762 bfd_boolean accept_numbers
,
763 bfd_boolean accept_list_names
)
770 /* Find the spelling of the operand. */
771 start
= name
= input_line_pointer
;
773 c
= get_symbol_end ();
774 reg_number
= reg_name_search (system_registers
, SYSREG_NAME_CNT
, name
,
777 /* Put back the delimiting char. */
778 *input_line_pointer
= c
;
783 /* Reset input_line pointer. */
784 input_line_pointer
= start
;
786 if (ISDIGIT (*input_line_pointer
))
788 reg_number
= strtol (input_line_pointer
, &input_line_pointer
, 10);
790 /* Make sure that the register number is allowable. */
792 || (reg_number
> 5 && reg_number
< 16)
796 else if (accept_list_names
)
798 c
= get_symbol_end ();
799 reg_number
= reg_name_search (system_list_registers
,
800 SYSREGLIST_NAME_CNT
, name
, FALSE
);
802 /* Put back the delimiting char. */
803 *input_line_pointer
= c
;
807 /* Look to see if it's in the register table. */
810 expressionP
->X_op
= O_register
;
811 expressionP
->X_add_number
= reg_number
;
813 /* Make the rest nice. */
814 expressionP
->X_add_symbol
= NULL
;
815 expressionP
->X_op_symbol
= NULL
;
821 /* Reset the line as if we had not done anything. */
822 input_line_pointer
= start
;
828 /* Summary of cc_name().
830 in: INPUT_LINE_POINTER points to 1st char of operand.
833 The operand may have been a register: in this case, X_op == O_register,
834 X_add_number is set to the register number, and truth is returned.
835 Input_line_pointer->(next non-blank) char after operand, or is in
836 its original state. */
839 cc_name (expressionS
*expressionP
)
846 /* Find the spelling of the operand. */
847 start
= name
= input_line_pointer
;
849 c
= get_symbol_end ();
850 reg_number
= reg_name_search (cc_names
, CC_NAME_CNT
, name
, FALSE
);
852 /* Put back the delimiting char. */
853 *input_line_pointer
= c
;
855 /* Look to see if it's in the register table. */
858 expressionP
->X_op
= O_constant
;
859 expressionP
->X_add_number
= reg_number
;
861 /* Make the rest nice. */
862 expressionP
->X_add_symbol
= NULL
;
863 expressionP
->X_op_symbol
= NULL
;
869 /* Reset the line as if we had not done anything. */
870 input_line_pointer
= start
;
877 skip_white_space (void)
879 while (*input_line_pointer
== ' '
880 || *input_line_pointer
== '\t')
881 ++input_line_pointer
;
884 /* Summary of parse_register_list ().
886 in: INPUT_LINE_POINTER points to 1st char of a list of registers.
887 INSN is the partially constructed instruction.
888 OPERAND is the operand being inserted.
890 out: NULL if the parse completed successfully, otherwise a
891 pointer to an error message is returned. If the parse
892 completes the correct bit fields in the instruction
895 Parses register lists with the syntax:
903 and also parses constant expressions whoes bits indicate the
904 registers in the lists. The LSB in the expression refers to
905 the lowest numbered permissible register in the register list,
906 and so on upwards. System registers are considered to be very
910 parse_register_list (unsigned long *insn
,
911 const struct v850_operand
*operand
)
913 static int type1_regs
[32] =
915 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
916 0, 0, 0, 0, 0, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
918 static int type2_regs
[32] =
920 19, 18, 17, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
921 0, 0, 0, 0, 30, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
923 static int type3_regs
[32] =
925 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
926 0, 0, 0, 0, 14, 15, 13, 12, 7, 6, 5, 4, 11, 10, 9, 8
931 /* Select a register array to parse. */
932 switch (operand
->shift
)
934 case 0xffe00001: regs
= type1_regs
; break;
935 case 0xfff8000f: regs
= type2_regs
; break;
936 case 0xfff8001f: regs
= type3_regs
; break;
938 as_bad (_("unknown operand shift: %x\n"), operand
->shift
);
939 return _("internal failure in parse_register_list");
944 /* If the expression starts with a curly brace it is a register list.
945 Otherwise it is a constant expression, whoes bits indicate which
946 registers are to be included in the list. */
947 if (*input_line_pointer
!= '{')
954 if (exp
.X_op
!= O_constant
)
955 return _("constant expression or register list expected");
957 if (regs
== type1_regs
)
959 if (exp
.X_add_number
& 0xFFFFF000)
960 return _("high bits set in register list expression");
962 for (reg
= 20; reg
< 32; reg
++)
963 if (exp
.X_add_number
& (1 << (reg
- 20)))
965 for (i
= 0; i
< 32; i
++)
970 else if (regs
== type2_regs
)
972 if (exp
.X_add_number
& 0xFFFE0000)
973 return _("high bits set in register list expression");
975 for (reg
= 1; reg
< 16; reg
++)
976 if (exp
.X_add_number
& (1 << (reg
- 1)))
978 for (i
= 0; i
< 32; i
++)
983 if (exp
.X_add_number
& (1 << 15))
986 if (exp
.X_add_number
& (1 << 16))
989 else /* regs == type3_regs */
991 if (exp
.X_add_number
& 0xFFFE0000)
992 return _("high bits set in register list expression");
994 for (reg
= 16; reg
< 32; reg
++)
995 if (exp
.X_add_number
& (1 << (reg
- 16)))
997 for (i
= 0; i
< 32; i
++)
1002 if (exp
.X_add_number
& (1 << 16))
1009 input_line_pointer
++;
1011 /* Parse the register list until a terminator (closing curly brace or
1012 new-line) is found. */
1015 if (register_name (&exp
))
1019 /* Locate the given register in the list, and if it is there,
1020 insert the corresponding bit into the instruction. */
1021 for (i
= 0; i
< 32; i
++)
1023 if (regs
[i
] == exp
.X_add_number
)
1031 return _("illegal register included in list");
1033 else if (system_register_name (&exp
, TRUE
, TRUE
))
1035 if (regs
== type1_regs
)
1037 return _("system registers cannot be included in list");
1039 else if (exp
.X_add_number
== 5)
1041 if (regs
== type2_regs
)
1042 return _("PSW cannot be included in list");
1046 else if (exp
.X_add_number
< 4)
1049 return _("High value system registers cannot be included in list");
1051 else if (*input_line_pointer
== '}')
1053 input_line_pointer
++;
1056 else if (*input_line_pointer
== ',')
1058 input_line_pointer
++;
1061 else if (*input_line_pointer
== '-')
1063 /* We have encountered a range of registers: rX - rY. */
1067 /* Skip the dash. */
1068 ++input_line_pointer
;
1070 /* Get the second register in the range. */
1071 if (! register_name (&exp2
))
1073 return _("second register should follow dash in register list");
1074 exp2
.X_add_number
= exp
.X_add_number
;
1077 /* Add the rest of the registers in the range. */
1078 for (j
= exp
.X_add_number
+ 1; j
<= exp2
.X_add_number
; j
++)
1082 /* Locate the given register in the list, and if it is there,
1083 insert the corresponding bit into the instruction. */
1084 for (i
= 0; i
< 32; i
++)
1094 return _("illegal register included in list");
1100 skip_white_space ();
1106 const char *md_shortopts
= "m:";
1108 struct option md_longopts
[] =
1110 {NULL
, no_argument
, NULL
, 0}
1113 size_t md_longopts_size
= sizeof (md_longopts
);
1116 md_show_usage (FILE *stream
)
1118 fprintf (stream
, _(" V850 options:\n"));
1119 fprintf (stream
, _(" -mwarn-signed-overflow Warn if signed immediate values overflow\n"));
1120 fprintf (stream
, _(" -mwarn-unsigned-overflow Warn if unsigned immediate values overflow\n"));
1121 fprintf (stream
, _(" -mv850 The code is targeted at the v850\n"));
1122 fprintf (stream
, _(" -mv850e The code is targeted at the v850e\n"));
1123 fprintf (stream
, _(" -mv850e1 The code is targeted at the v850e1\n"));
1124 fprintf (stream
, _(" -mv850any The code is generic, despite any processor specific instructions\n"));
1125 fprintf (stream
, _(" -mrelax Enable relaxation\n"));
1129 md_parse_option (int c
, char *arg
)
1134 if (strcmp (arg
, "warn-signed-overflow") == 0)
1135 warn_signed_overflows
= TRUE
;
1137 else if (strcmp (arg
, "warn-unsigned-overflow") == 0)
1138 warn_unsigned_overflows
= TRUE
;
1140 else if (strcmp (arg
, "v850") == 0)
1143 processor_mask
= PROCESSOR_V850
;
1145 else if (strcmp (arg
, "v850e") == 0)
1147 machine
= bfd_mach_v850e
;
1148 processor_mask
= PROCESSOR_V850E
;
1150 else if (strcmp (arg
, "v850e1") == 0)
1152 machine
= bfd_mach_v850e1
;
1153 processor_mask
= PROCESSOR_V850E1
;
1155 else if (strcmp (arg
, "v850any") == 0)
1157 /* Tell the world that this is for any v850 chip. */
1160 /* But support instructions for the extended versions. */
1161 processor_mask
= PROCESSOR_V850E
;
1162 processor_mask
|= PROCESSOR_V850E1
;
1164 else if (strcmp (arg
, "relax") == 0)
1173 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
1179 md_atof (int type
, char *litp
, int *sizep
)
1182 LITTLENUM_TYPE words
[4];
1198 return _("bad call to md_atof");
1201 t
= atof_ieee (input_line_pointer
, type
, words
);
1203 input_line_pointer
= t
;
1207 for (i
= prec
- 1; i
>= 0; i
--)
1209 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
1219 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
1223 /* This code performs some nasty type punning between the
1224 fr_opcode field of the frag structure (a char *) and the
1225 fx_r_type field of the fix structure (a bfd_reloc_code_real_type)
1226 On a 64bit host this causes problems because these two fields
1227 are not the same size, but since we know that we are only
1228 ever storing small integers in the fields, it is safe to use
1229 a union to convert between them. */
1232 bfd_reloc_code_real_type fx_r_type
;
1236 subseg_change (sec
, 0);
1238 opcode_converter
.fr_opcode
= fragP
->fr_opcode
;
1240 /* In range conditional or unconditional branch. */
1241 if (fragP
->fr_subtype
== 0 || fragP
->fr_subtype
== 2)
1243 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
,
1244 fragP
->fr_offset
, 1,
1245 BFD_RELOC_UNUSED
+ opcode_converter
.fx_r_type
);
1248 /* Out of range conditional branch. Emit a branch around a jump. */
1249 else if (fragP
->fr_subtype
== 1)
1251 unsigned char *buffer
=
1252 (unsigned char *) (fragP
->fr_fix
+ fragP
->fr_literal
);
1254 /* Reverse the condition of the first branch. */
1256 /* Mask off all the displacement bits. */
1259 /* Now set the displacement bits so that we branch
1260 around the unconditional branch. */
1263 /* Now create the unconditional branch + fixup to the final
1265 md_number_to_chars ((char *) buffer
+ 2, 0x00000780, 4);
1266 fix_new (fragP
, fragP
->fr_fix
+ 2, 4, fragP
->fr_symbol
,
1267 fragP
->fr_offset
, 1,
1268 BFD_RELOC_UNUSED
+ opcode_converter
.fx_r_type
+ 1);
1271 /* Out of range unconditional branch. Emit a jump. */
1272 else if (fragP
->fr_subtype
== 3)
1274 md_number_to_chars (fragP
->fr_fix
+ fragP
->fr_literal
, 0x00000780, 4);
1275 fix_new (fragP
, fragP
->fr_fix
, 4, fragP
->fr_symbol
,
1276 fragP
->fr_offset
, 1,
1277 BFD_RELOC_UNUSED
+ opcode_converter
.fx_r_type
+ 1);
1285 md_section_align (asection
*seg
, valueT addr
)
1287 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1288 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1294 char *prev_name
= "";
1295 const struct v850_opcode
*op
;
1297 if (strncmp (TARGET_CPU
, "v850e1", 6) == 0)
1300 machine
= bfd_mach_v850e1
;
1302 if (processor_mask
== -1)
1303 processor_mask
= PROCESSOR_V850E1
;
1305 else if (strncmp (TARGET_CPU
, "v850e", 5) == 0)
1308 machine
= bfd_mach_v850e
;
1310 if (processor_mask
== -1)
1311 processor_mask
= PROCESSOR_V850E
;
1313 else if (strncmp (TARGET_CPU
, "v850", 4) == 0)
1318 if (processor_mask
== -1)
1319 processor_mask
= PROCESSOR_V850
;
1322 /* xgettext:c-format */
1323 as_bad (_("Unable to determine default target processor from string: %s"),
1326 v850_hash
= hash_new ();
1328 /* Insert unique names into hash table. The V850 instruction set
1329 has many identical opcode names that have different opcodes based
1330 on the operands. This hash table then provides a quick index to
1331 the first opcode with a particular name in the opcode table. */
1335 if (strcmp (prev_name
, op
->name
))
1337 prev_name
= (char *) op
->name
;
1338 hash_insert (v850_hash
, op
->name
, (char *) op
);
1343 v850_seg_table
[BSS_SECTION
].s
= bss_section
;
1344 bfd_set_arch_mach (stdoutput
, TARGET_ARCH
, machine
);
1347 static bfd_reloc_code_real_type
1348 handle_lo16 (const struct v850_operand
*operand
)
1350 if (operand
!= NULL
)
1352 if (operand
->bits
== -1)
1353 return BFD_RELOC_V850_LO16_SPLIT_OFFSET
;
1355 if (!(operand
->bits
== 16 && operand
->shift
== 16)
1356 && !(operand
->bits
== 15 && operand
->shift
== 17))
1358 as_bad (_("lo() relocation used on an instruction which does "
1360 return BFD_RELOC_64
; /* Used to indicate an error condition. */
1363 return BFD_RELOC_LO16
;
1366 static bfd_reloc_code_real_type
1367 handle_ctoff (const struct v850_operand
*operand
)
1369 if (operand
== NULL
)
1370 return BFD_RELOC_V850_CALLT_16_16_OFFSET
;
1372 if (operand
->bits
!= 6
1373 || operand
->shift
!= 0)
1375 as_bad (_("ctoff() relocation used on an instruction which does not support it"));
1376 return BFD_RELOC_64
; /* Used to indicate an error condition. */
1379 return BFD_RELOC_V850_CALLT_6_7_OFFSET
;
1382 static bfd_reloc_code_real_type
1383 handle_sdaoff (const struct v850_operand
*operand
)
1385 if (operand
== NULL
)
1386 return BFD_RELOC_V850_SDA_16_16_OFFSET
;
1388 if (operand
->bits
== 15 && operand
->shift
== 17)
1389 return BFD_RELOC_V850_SDA_15_16_OFFSET
;
1391 if (operand
->bits
== -1)
1392 return BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
;
1394 if (operand
->bits
!= 16
1395 || operand
->shift
!= 16)
1397 as_bad (_("sdaoff() relocation used on an instruction which does not support it"));
1398 return BFD_RELOC_64
; /* Used to indicate an error condition. */
1401 return BFD_RELOC_V850_SDA_16_16_OFFSET
;
1404 static bfd_reloc_code_real_type
1405 handle_zdaoff (const struct v850_operand
*operand
)
1407 if (operand
== NULL
)
1408 return BFD_RELOC_V850_ZDA_16_16_OFFSET
;
1410 if (operand
->bits
== 15 && operand
->shift
== 17)
1411 return BFD_RELOC_V850_ZDA_15_16_OFFSET
;
1413 if (operand
->bits
== -1)
1414 return BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
;
1416 if (operand
->bits
!= 16
1417 || operand
->shift
!= 16)
1419 as_bad (_("zdaoff() relocation used on an instruction which does not support it"));
1420 /* Used to indicate an error condition. */
1421 return BFD_RELOC_64
;
1424 return BFD_RELOC_V850_ZDA_16_16_OFFSET
;
1427 static bfd_reloc_code_real_type
1428 handle_tdaoff (const struct v850_operand
*operand
)
1430 if (operand
== NULL
)
1431 /* Data item, not an instruction. */
1432 return BFD_RELOC_V850_TDA_7_7_OFFSET
;
1434 if (operand
->bits
== 6 && operand
->shift
== 1)
1435 /* sld.w/sst.w, operand: D8_6. */
1436 return BFD_RELOC_V850_TDA_6_8_OFFSET
;
1438 if (operand
->bits
== 4 && operand
->insert
!= NULL
)
1439 /* sld.hu, operand: D5-4. */
1440 return BFD_RELOC_V850_TDA_4_5_OFFSET
;
1442 if (operand
->bits
== 4 && operand
->insert
== NULL
)
1443 /* sld.bu, operand: D4. */
1444 return BFD_RELOC_V850_TDA_4_4_OFFSET
;
1446 if (operand
->bits
== 16 && operand
->shift
== 16)
1447 /* set1 & chums, operands: D16. */
1448 return BFD_RELOC_V850_TDA_16_16_OFFSET
;
1450 if (operand
->bits
!= 7)
1452 as_bad (_("tdaoff() relocation used on an instruction which does not support it"));
1453 /* Used to indicate an error condition. */
1454 return BFD_RELOC_64
;
1457 return operand
->insert
!= NULL
1458 ? BFD_RELOC_V850_TDA_7_8_OFFSET
/* sld.h/sst.h, operand: D8_7. */
1459 : BFD_RELOC_V850_TDA_7_7_OFFSET
; /* sld.b/sst.b, operand: D7. */
1462 /* Warning: The code in this function relies upon the definitions
1463 in the v850_operands[] array (defined in opcodes/v850-opc.c)
1464 matching the hard coded values contained herein. */
1466 static bfd_reloc_code_real_type
1467 v850_reloc_prefix (const struct v850_operand
*operand
)
1469 bfd_boolean paren_skipped
= FALSE
;
1471 /* Skip leading opening parenthesis. */
1472 if (*input_line_pointer
== '(')
1474 ++input_line_pointer
;
1475 paren_skipped
= TRUE
;
1478 #define CHECK_(name, reloc) \
1479 if (strncmp (input_line_pointer, name "(", strlen (name) + 1) == 0) \
1481 input_line_pointer += strlen (name); \
1485 CHECK_ ("hi0", BFD_RELOC_HI16
);
1486 CHECK_ ("hi", BFD_RELOC_HI16_S
);
1487 CHECK_ ("lo", handle_lo16 (operand
) );
1488 CHECK_ ("sdaoff", handle_sdaoff (operand
));
1489 CHECK_ ("zdaoff", handle_zdaoff (operand
));
1490 CHECK_ ("tdaoff", handle_tdaoff (operand
));
1491 CHECK_ ("hilo", BFD_RELOC_32
);
1492 CHECK_ ("ctoff", handle_ctoff (operand
) );
1494 /* Restore skipped parenthesis. */
1496 --input_line_pointer
;
1498 return BFD_RELOC_UNUSED
;
1501 /* Insert an operand value into an instruction. */
1503 static unsigned long
1504 v850_insert_operand (unsigned long insn
,
1505 const struct v850_operand
*operand
,
1511 if (operand
->insert
)
1513 const char *message
= NULL
;
1515 insn
= operand
->insert (insn
, val
, &message
);
1516 if (message
!= NULL
)
1518 if ((operand
->flags
& V850_OPERAND_SIGNED
)
1519 && ! warn_signed_overflows
1520 && strstr (message
, "out of range") != NULL
)
1522 /* Skip warning... */
1524 else if ((operand
->flags
& V850_OPERAND_SIGNED
) == 0
1525 && ! warn_unsigned_overflows
1526 && strstr (message
, "out of range") != NULL
)
1528 /* Skip warning... */
1532 if (file
== (char *) NULL
)
1533 as_warn ("%s: %s", str
, message
);
1535 as_warn_where (file
, line
, "%s: %s", str
, message
);
1539 if (file
== (char *) NULL
)
1542 as_warn_where (file
, line
, message
);
1548 if (operand
->bits
!= 32)
1552 if ((operand
->flags
& V850_OPERAND_SIGNED
) != 0)
1554 if (! warn_signed_overflows
)
1555 max
= (1 << operand
->bits
) - 1;
1557 max
= (1 << (operand
->bits
- 1)) - 1;
1559 min
= -(1 << (operand
->bits
- 1));
1563 max
= (1 << operand
->bits
) - 1;
1565 if (! warn_unsigned_overflows
)
1566 min
= -(1 << (operand
->bits
- 1));
1571 if (val
< (offsetT
) min
|| val
> (offsetT
) max
)
1575 /* Restore min and mix to expected values for decimal ranges. */
1576 if ((operand
->flags
& V850_OPERAND_SIGNED
)
1577 && ! warn_signed_overflows
)
1578 max
= (1 << (operand
->bits
- 1)) - 1;
1580 if (! (operand
->flags
& V850_OPERAND_SIGNED
)
1581 && ! warn_unsigned_overflows
)
1585 sprintf (buf
, "%s: ", str
);
1588 strcat (buf
, _("operand"));
1590 as_bad_value_out_of_range (buf
, val
, (offsetT
) min
, (offsetT
) max
, file
, line
);
1594 insn
|= (((long) val
& ((1 << operand
->bits
) - 1)) << operand
->shift
);
1600 static char copy_of_instruction
[128];
1603 md_assemble (char *str
)
1606 char *start_of_operands
;
1607 struct v850_opcode
*opcode
;
1608 struct v850_opcode
*next_opcode
;
1609 const unsigned char *opindex_ptr
;
1613 unsigned long insn_size
;
1617 bfd_boolean extra_data_after_insn
= FALSE
;
1618 unsigned extra_data_len
= 0;
1619 unsigned long extra_data
= 0;
1620 char *saved_input_line_pointer
;
1622 strncpy (copy_of_instruction
, str
, sizeof (copy_of_instruction
) - 1);
1624 /* Get the opcode. */
1625 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1631 /* Find the first opcode with the proper name. */
1632 opcode
= (struct v850_opcode
*) hash_find (v850_hash
, str
);
1635 /* xgettext:c-format */
1636 as_bad (_("Unrecognized opcode: `%s'"), str
);
1637 ignore_rest_of_line ();
1642 while (ISSPACE (*str
))
1645 start_of_operands
= str
;
1647 saved_input_line_pointer
= input_line_pointer
;
1651 const char *errmsg
= NULL
;
1655 if ((opcode
->processors
& processor_mask
) == 0)
1657 errmsg
= _("Target processor does not support this instruction.");
1664 insn
= opcode
->opcode
;
1665 extra_data_after_insn
= FALSE
;
1667 input_line_pointer
= str
= start_of_operands
;
1669 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1671 const struct v850_operand
*operand
;
1674 bfd_reloc_code_real_type reloc
;
1676 if (next_opindex
== 0)
1677 operand
= &v850_operands
[*opindex_ptr
];
1680 operand
= &v850_operands
[next_opindex
];
1686 while (*str
== ' ' || *str
== ',' || *str
== '[' || *str
== ']')
1689 if (operand
->flags
& V850_OPERAND_RELAX
)
1692 /* Gather the operand. */
1693 hold
= input_line_pointer
;
1694 input_line_pointer
= str
;
1696 /* lo(), hi(), hi0(), etc... */
1697 if ((reloc
= v850_reloc_prefix (operand
)) != BFD_RELOC_UNUSED
)
1699 /* This is a fake reloc, used to indicate an error condition. */
1700 if (reloc
== BFD_RELOC_64
)
1708 if (ex
.X_op
== O_constant
)
1712 case BFD_RELOC_V850_ZDA_16_16_OFFSET
:
1713 /* To cope with "not1 7, zdaoff(0xfffff006)[r0]"
1717 case BFD_RELOC_LO16
:
1718 case BFD_RELOC_V850_LO16_SPLIT_OFFSET
:
1720 /* Truncate, then sign extend the value. */
1721 ex
.X_add_number
= SEXT16 (ex
.X_add_number
);
1725 case BFD_RELOC_HI16
:
1727 /* Truncate, then sign extend the value. */
1728 ex
.X_add_number
= SEXT16 (ex
.X_add_number
>> 16);
1732 case BFD_RELOC_HI16_S
:
1734 /* Truncate, then sign extend the value. */
1735 int temp
= (ex
.X_add_number
>> 16) & 0xffff;
1737 temp
+= (ex
.X_add_number
>> 15) & 1;
1739 ex
.X_add_number
= SEXT16 (temp
);
1744 if ((operand
->flags
& V850E_IMMEDIATE32
) == 0)
1746 errmsg
= _("immediate operand is too large");
1750 extra_data_after_insn
= TRUE
;
1756 fprintf (stderr
, "reloc: %d\n", reloc
);
1757 as_bad (_("AAARG -> unhandled constant reloc"));
1761 if (fc
> MAX_INSN_FIXUPS
)
1762 as_fatal (_("too many fixups"));
1764 fixups
[fc
].exp
= ex
;
1765 fixups
[fc
].opindex
= *opindex_ptr
;
1766 fixups
[fc
].reloc
= reloc
;
1771 if (reloc
== BFD_RELOC_32
)
1773 if ((operand
->flags
& V850E_IMMEDIATE32
) == 0)
1775 errmsg
= _("immediate operand is too large");
1779 extra_data_after_insn
= TRUE
;
1781 extra_data
= ex
.X_add_number
;
1784 if (fc
> MAX_INSN_FIXUPS
)
1785 as_fatal (_("too many fixups"));
1787 fixups
[fc
].exp
= ex
;
1788 fixups
[fc
].opindex
= *opindex_ptr
;
1789 fixups
[fc
].reloc
= reloc
;
1797 if ((operand
->flags
& V850_OPERAND_REG
) != 0)
1799 if (!register_name (&ex
))
1800 errmsg
= _("invalid register name");
1801 else if ((operand
->flags
& V850_NOT_R0
)
1802 && ex
.X_add_number
== 0)
1804 errmsg
= _("register r0 cannot be used here");
1806 /* Force an error message to be generated by
1807 skipping over any following potential matches
1812 else if ((operand
->flags
& V850_OPERAND_SRG
) != 0)
1814 if (!system_register_name (&ex
, TRUE
, FALSE
))
1815 errmsg
= _("invalid system register name");
1817 else if ((operand
->flags
& V850_OPERAND_EP
) != 0)
1819 char *start
= input_line_pointer
;
1820 char c
= get_symbol_end ();
1822 if (strcmp (start
, "ep") != 0 && strcmp (start
, "r30") != 0)
1824 /* Put things back the way we found them. */
1825 *input_line_pointer
= c
;
1826 input_line_pointer
= start
;
1827 errmsg
= _("expected EP register");
1831 *input_line_pointer
= c
;
1832 str
= input_line_pointer
;
1833 input_line_pointer
= hold
;
1835 while (*str
== ' ' || *str
== ','
1836 || *str
== '[' || *str
== ']')
1840 else if ((operand
->flags
& V850_OPERAND_CC
) != 0)
1843 errmsg
= _("invalid condition code name");
1845 else if (operand
->flags
& V850E_PUSH_POP
)
1847 errmsg
= parse_register_list (&insn
, operand
);
1849 /* The parse_register_list() function has already done
1850 everything, so fake a dummy expression. */
1851 ex
.X_op
= O_constant
;
1852 ex
.X_add_number
= 0;
1854 else if (operand
->flags
& V850E_IMMEDIATE16
)
1858 if (ex
.X_op
!= O_constant
)
1859 errmsg
= _("constant expression expected");
1860 else if (ex
.X_add_number
& 0xffff0000)
1862 if (ex
.X_add_number
& 0xffff)
1863 errmsg
= _("constant too big to fit into instruction");
1864 else if ((insn
& 0x001fffc0) == 0x00130780)
1865 ex
.X_add_number
>>= 16;
1867 errmsg
= _("constant too big to fit into instruction");
1870 extra_data_after_insn
= TRUE
;
1872 extra_data
= ex
.X_add_number
;
1873 ex
.X_add_number
= 0;
1875 else if (operand
->flags
& V850E_IMMEDIATE32
)
1879 if (ex
.X_op
!= O_constant
)
1880 errmsg
= _("constant expression expected");
1882 extra_data_after_insn
= TRUE
;
1884 extra_data
= ex
.X_add_number
;
1885 ex
.X_add_number
= 0;
1887 else if (register_name (&ex
)
1888 && (operand
->flags
& V850_OPERAND_REG
) == 0)
1893 /* It is possible that an alias has been defined that
1894 matches a register name. For example the code may
1895 include a ".set ZERO, 0" directive, which matches
1896 the register name "zero". Attempt to reparse the
1897 field as an expression, and only complain if we
1898 cannot generate a constant. */
1900 input_line_pointer
= str
;
1902 c
= get_symbol_end ();
1904 if (symbol_find (str
) != NULL
)
1907 *input_line_pointer
= c
;
1908 input_line_pointer
= str
;
1912 if (ex
.X_op
!= O_constant
)
1914 /* If this register is actually occurring too early on
1915 the parsing of the instruction, (because another
1916 field is missing) then report this. */
1917 if (opindex_ptr
[1] != 0
1918 && (v850_operands
[opindex_ptr
[1]].flags
1919 & V850_OPERAND_REG
))
1920 errmsg
= _("syntax error: value is missing before the register name");
1922 errmsg
= _("syntax error: register not expected");
1924 /* If we created a symbol in the process of this
1925 test then delete it now, so that it will not
1926 be output with the real symbols... */
1928 && ex
.X_op
== O_symbol
)
1929 symbol_remove (ex
.X_add_symbol
,
1930 &symbol_rootP
, &symbol_lastP
);
1933 else if (system_register_name (&ex
, FALSE
, FALSE
)
1934 && (operand
->flags
& V850_OPERAND_SRG
) == 0)
1935 errmsg
= _("syntax error: system register not expected");
1937 else if (cc_name (&ex
)
1938 && (operand
->flags
& V850_OPERAND_CC
) == 0)
1939 errmsg
= _("syntax error: condition code not expected");
1945 If we are assembling a MOV instruction and the immediate
1946 value does not fit into the bits available then create a
1947 fake error so that the next MOV instruction will be
1948 selected. This one has a 32 bit immediate field. */
1950 if (((insn
& 0x07e0) == 0x0200)
1951 && operand
->bits
== 5 /* Do not match the CALLT instruction. */
1952 && ex
.X_op
== O_constant
1953 && (ex
.X_add_number
< (-(1 << (operand
->bits
- 1)))
1954 || ex
.X_add_number
> ((1 << (operand
->bits
- 1)) - 1)))
1955 errmsg
= _("immediate operand is too large");
1964 errmsg
= _("illegal operand");
1967 errmsg
= _("missing operand");
1971 & (V850_OPERAND_REG
| V850_OPERAND_SRG
)) == 0)
1973 errmsg
= _("invalid operand");
1976 insn
= v850_insert_operand (insn
, operand
, ex
.X_add_number
,
1977 NULL
, 0, copy_of_instruction
);
1981 insn
= v850_insert_operand (insn
, operand
, ex
.X_add_number
,
1982 NULL
, 0, copy_of_instruction
);
1986 /* We need to generate a fixup for this expression. */
1987 if (fc
>= MAX_INSN_FIXUPS
)
1988 as_fatal (_("too many fixups"));
1990 fixups
[fc
].exp
= ex
;
1991 fixups
[fc
].opindex
= *opindex_ptr
;
1992 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1998 str
= input_line_pointer
;
1999 input_line_pointer
= hold
;
2001 while (*str
== ' ' || *str
== ',' || *str
== '[' || *str
== ']'
2010 next_opcode
= opcode
+ 1;
2011 if (next_opcode
->name
!= NULL
2012 && strcmp (next_opcode
->name
, opcode
->name
) == 0)
2014 opcode
= next_opcode
;
2016 /* Skip versions that are not supported by the target
2018 if ((opcode
->processors
& processor_mask
) == 0)
2024 as_bad ("%s: %s", copy_of_instruction
, errmsg
);
2026 if (*input_line_pointer
== ']')
2027 ++input_line_pointer
;
2029 ignore_rest_of_line ();
2030 input_line_pointer
= saved_input_line_pointer
;
2036 while (ISSPACE (*str
))
2040 /* xgettext:c-format */
2041 as_bad (_("junk at end of line: `%s'"), str
);
2043 input_line_pointer
= str
;
2045 /* Tie dwarf2 debug info to the address at the start of the insn.
2046 We can't do this after the insn has been output as the current
2047 frag may have been closed off. eg. by frag_var. */
2048 dwarf2_emit_insn (0);
2050 /* Write out the instruction. */
2052 if (relaxable
&& fc
> 0)
2054 /* On a 64-bit host the size of an 'int' is not the same
2055 as the size of a pointer, so we need a union to convert
2056 the opindex field of the fr_cgen structure into a char *
2057 so that it can be stored in the frag. We do not have
2058 to worry about loosing accuracy as we are not going to
2059 be even close to the 32bit limit of the int. */
2067 opindex_converter
.opindex
= fixups
[0].opindex
;
2071 if (!strcmp (opcode
->name
, "br"))
2073 f
= frag_var (rs_machine_dependent
, 4, 2, 2,
2074 fixups
[0].exp
.X_add_symbol
,
2075 fixups
[0].exp
.X_add_number
,
2076 opindex_converter
.ptr
);
2077 md_number_to_chars (f
, insn
, insn_size
);
2078 md_number_to_chars (f
+ 2, 0, 2);
2082 f
= frag_var (rs_machine_dependent
, 6, 4, 0,
2083 fixups
[0].exp
.X_add_symbol
,
2084 fixups
[0].exp
.X_add_number
,
2085 opindex_converter
.ptr
);
2086 md_number_to_chars (f
, insn
, insn_size
);
2087 md_number_to_chars (f
+ 2, 0, 4);
2092 /* Four byte insns have an opcode with the two high bits on. */
2093 if ((insn
& 0x0600) == 0x0600)
2098 /* Special case: 32 bit MOV. */
2099 if ((insn
& 0xffe0) == 0x0620)
2102 f
= frag_more (insn_size
);
2103 md_number_to_chars (f
, insn
, insn_size
);
2105 if (extra_data_after_insn
)
2107 f
= frag_more (extra_data_len
);
2108 md_number_to_chars (f
, extra_data
, extra_data_len
);
2110 extra_data_after_insn
= FALSE
;
2114 /* Create any fixups. At this point we do not use a
2115 bfd_reloc_code_real_type, but instead just use the
2116 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2117 handle fixups for any operand type, although that is admittedly
2118 not a very exciting feature. We pick a BFD reloc type in
2120 for (i
= 0; i
< fc
; i
++)
2122 const struct v850_operand
*operand
;
2123 bfd_reloc_code_real_type reloc
;
2125 operand
= &v850_operands
[fixups
[i
].opindex
];
2127 reloc
= fixups
[i
].reloc
;
2129 if (reloc
!= BFD_RELOC_UNUSED
)
2131 reloc_howto_type
*reloc_howto
=
2132 bfd_reloc_type_lookup (stdoutput
, reloc
);
2140 size
= bfd_get_reloc_size (reloc_howto
);
2142 /* XXX This will abort on an R_V850_8 reloc -
2143 is this reloc actually used? */
2144 if (size
!= 2 && size
!= 4)
2147 address
= (f
- frag_now
->fr_literal
) + insn_size
- size
;
2149 if (reloc
== BFD_RELOC_32
)
2152 fixP
= fix_new_exp (frag_now
, address
, size
,
2154 reloc_howto
->pc_relative
,
2157 fixP
->tc_fix_data
= (void *) operand
;
2161 case BFD_RELOC_LO16
:
2162 case BFD_RELOC_V850_LO16_SPLIT_OFFSET
:
2163 case BFD_RELOC_HI16
:
2164 case BFD_RELOC_HI16_S
:
2165 fixP
->fx_no_overflow
= 1;
2173 fix_new_exp (frag_now
,
2174 f
- frag_now
->fr_literal
, 4,
2176 (operand
->flags
& V850_OPERAND_DISP
) != 0,
2177 (bfd_reloc_code_real_type
) (fixups
[i
].opindex
2178 + (int) BFD_RELOC_UNUSED
));
2182 input_line_pointer
= saved_input_line_pointer
;
2185 /* If while processing a fixup, a reloc really needs to be created
2186 then it is done here. */
2189 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
2193 reloc
= xmalloc (sizeof (arelent
));
2194 reloc
->sym_ptr_ptr
= xmalloc (sizeof (asymbol
*));
2195 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2196 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2198 if ( fixp
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
2199 || fixp
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2200 || fixp
->fx_r_type
== BFD_RELOC_V850_LONGCALL
2201 || fixp
->fx_r_type
== BFD_RELOC_V850_LONGJUMP
2202 || fixp
->fx_r_type
== BFD_RELOC_V850_ALIGN
)
2203 reloc
->addend
= fixp
->fx_offset
;
2206 if (fixp
->fx_r_type
== BFD_RELOC_32
2208 fixp
->fx_r_type
= BFD_RELOC_32_PCREL
;
2210 reloc
->addend
= fixp
->fx_addnumber
;
2213 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
2215 if (reloc
->howto
== NULL
)
2217 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2218 /* xgettext:c-format */
2219 _("reloc %d not supported by object file format"),
2220 (int) fixp
->fx_r_type
);
2231 v850_handle_align (fragS
* frag
)
2234 && frag
->fr_type
== rs_align
2235 && frag
->fr_address
+ frag
->fr_fix
> 0
2236 && frag
->fr_offset
> 1
2237 && now_seg
!= bss_section
2238 && now_seg
!= v850_seg_table
[SBSS_SECTION
].s
2239 && now_seg
!= v850_seg_table
[TBSS_SECTION
].s
2240 && now_seg
!= v850_seg_table
[ZBSS_SECTION
].s
)
2241 fix_new (frag
, frag
->fr_fix
, 2, & abs_symbol
, frag
->fr_offset
, 0,
2242 BFD_RELOC_V850_ALIGN
);
2245 /* Return current size of variable part of frag. */
2248 md_estimate_size_before_relax (fragS
*fragp
, asection
*seg ATTRIBUTE_UNUSED
)
2250 if (fragp
->fr_subtype
>= sizeof (md_relax_table
) / sizeof (md_relax_table
[0]))
2253 return md_relax_table
[fragp
->fr_subtype
].rlx_length
;
2257 v850_pcrel_from_section (fixS
*fixp
, segT section
)
2259 /* If the symbol is undefined, or in a section other than our own,
2260 or it is weak (in which case it may well be in another section,
2261 then let the linker figure it out. */
2262 if (fixp
->fx_addsy
!= (symbolS
*) NULL
2263 && (! S_IS_DEFINED (fixp
->fx_addsy
)
2264 || S_IS_WEAK (fixp
->fx_addsy
)
2265 || (S_GET_SEGMENT (fixp
->fx_addsy
) != section
)))
2268 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2272 md_apply_fix (fixS
*fixP
, valueT
*valueP
, segT seg ATTRIBUTE_UNUSED
)
2274 valueT value
= * valueP
;
2277 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2278 || fixP
->fx_r_type
== BFD_RELOC_V850_LONGCALL
2279 || fixP
->fx_r_type
== BFD_RELOC_V850_LONGJUMP
2280 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2286 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
2287 fixP
->fx_addnumber
= value
,
2290 else if (fixP
->fx_pcrel
)
2291 fixP
->fx_addnumber
= fixP
->fx_offset
;
2295 value
= fixP
->fx_offset
;
2296 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
2298 if (S_GET_SEGMENT (fixP
->fx_subsy
) == absolute_section
)
2299 value
-= S_GET_VALUE (fixP
->fx_subsy
);
2301 /* We don't actually support subtracting a symbol. */
2302 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2303 _("expression too complex"));
2305 fixP
->fx_addnumber
= value
;
2308 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
2311 const struct v850_operand
*operand
;
2314 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
2315 operand
= &v850_operands
[opindex
];
2317 /* Fetch the instruction, insert the fully resolved operand
2318 value, and stuff the instruction back again.
2320 Note the instruction has been stored in little endian
2322 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2324 insn
= bfd_getl32 ((unsigned char *) where
);
2325 insn
= v850_insert_operand (insn
, operand
, (offsetT
) value
,
2326 fixP
->fx_file
, fixP
->fx_line
, NULL
);
2327 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
2330 /* Nothing else to do here. */
2333 /* Determine a BFD reloc value based on the operand information.
2334 We are only prepared to turn a few of the operands into relocs. */
2336 if (operand
->bits
== 22)
2337 fixP
->fx_r_type
= BFD_RELOC_V850_22_PCREL
;
2338 else if (operand
->bits
== 9)
2339 fixP
->fx_r_type
= BFD_RELOC_V850_9_PCREL
;
2342 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2343 _("unresolved expression that must be resolved"));
2348 else if (fixP
->fx_done
)
2350 /* We still have to insert the value into memory! */
2351 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2353 if (fixP
->tc_fix_data
!= NULL
2354 && ((struct v850_operand
*) fixP
->tc_fix_data
)->insert
!= NULL
)
2356 const char * message
= NULL
;
2357 struct v850_operand
* operand
= (struct v850_operand
*) fixP
->tc_fix_data
;
2360 /* The variable "where" currently points at the exact point inside
2361 the insn where we need to insert the value. But we need to
2362 extract the entire insn so we probably need to move "where"
2363 back a few bytes. */
2364 if (fixP
->fx_size
== 2)
2366 else if (fixP
->fx_size
== 1)
2369 insn
= bfd_getl32 ((unsigned char *) where
);
2371 /* Use the operand's insertion procedure, if present, in order to
2372 make sure that the value is correctly stored in the insn. */
2373 insn
= operand
->insert (insn
, (offsetT
) value
, & message
);
2374 /* Ignore message even if it is set. */
2376 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
2380 if (fixP
->fx_r_type
== BFD_RELOC_V850_LO16_SPLIT_OFFSET
)
2381 bfd_putl32 (((value
<< 16) & 0xfffe0000)
2382 | ((value
<< 5) & 0x20)
2383 | (bfd_getl32 (where
) & ~0xfffe0020), where
);
2384 else if (fixP
->fx_size
== 1)
2385 *where
= value
& 0xff;
2386 else if (fixP
->fx_size
== 2)
2387 bfd_putl16 (value
& 0xffff, (unsigned char *) where
);
2388 else if (fixP
->fx_size
== 4)
2389 bfd_putl32 (value
, (unsigned char *) where
);
2394 /* Parse a cons expression. We have to handle hi(), lo(), etc
2398 parse_cons_expression_v850 (expressionS
*exp
)
2400 /* See if there's a reloc prefix like hi() we have to handle. */
2401 hold_cons_reloc
= v850_reloc_prefix (NULL
);
2403 /* Do normal expression parsing. */
2407 /* Create a fixup for a cons expression. If parse_cons_expression_v850
2408 found a reloc prefix, then we use that reloc, else we choose an
2409 appropriate one based on the size of the expression. */
2412 cons_fix_new_v850 (fragS
*frag
,
2417 if (hold_cons_reloc
== BFD_RELOC_UNUSED
)
2420 hold_cons_reloc
= BFD_RELOC_32
;
2422 hold_cons_reloc
= BFD_RELOC_16
;
2424 hold_cons_reloc
= BFD_RELOC_8
;
2428 fix_new_exp (frag
, where
, size
, exp
, 0, hold_cons_reloc
);
2430 fix_new (frag
, where
, size
, NULL
, 0, 0, hold_cons_reloc
);
2432 hold_cons_reloc
= BFD_RELOC_UNUSED
;
2436 v850_fix_adjustable (fixS
*fixP
)
2438 if (fixP
->fx_addsy
== NULL
)
2441 /* Don't adjust function names. */
2442 if (S_IS_FUNCTION (fixP
->fx_addsy
))
2445 /* We need the symbol name for the VTABLE entries. */
2446 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2447 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2454 v850_force_relocation (struct fix
*fixP
)
2456 if (fixP
->fx_r_type
== BFD_RELOC_V850_LONGCALL
2457 || fixP
->fx_r_type
== BFD_RELOC_V850_LONGJUMP
)
2462 || fixP
->fx_r_type
== BFD_RELOC_V850_ALIGN
2463 || fixP
->fx_r_type
== BFD_RELOC_V850_22_PCREL
2464 || fixP
->fx_r_type
== BFD_RELOC_V850_9_PCREL
2465 || fixP
->fx_r_type
>= BFD_RELOC_UNUSED
))
2468 return generic_force_reloc (fixP
);