1 /* tc-v850.c -- Assembler code for the NEC V850
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 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 2, 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, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "safe-ctype.h"
26 #include "opcode/v850.h"
27 #include "dwarf2dbg.h"
29 /* Sign-extend a 16-bit number. */
30 #define SEXT16(x) ((((x) & 0xffff) ^ (~0x7fff)) + 0x8000)
32 /* Temporarily holds the reloc in a cons expression. */
33 static bfd_reloc_code_real_type hold_cons_reloc
= BFD_RELOC_UNUSED
;
35 /* Set to TRUE if we want to be pedantic about signed overflows. */
36 static bfd_boolean warn_signed_overflows
= FALSE
;
37 static bfd_boolean warn_unsigned_overflows
= FALSE
;
39 /* Indicates the target BFD machine number. */
40 static int machine
= -1;
42 /* Indicates the target processor(s) for the assemble. */
43 static int processor_mask
= -1;
45 /* 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
[] = {
73 /* Conditional branches. */
75 {0x1fffff, -0x200000, 6, 0},
76 /* Unconditional branches. */
78 {0x1fffff, -0x200000, 4, 0},
81 static int v850_relax
= 0;
84 #define MAX_INSN_FIXUPS (5)
88 bfd_reloc_code_real_type reloc
;
91 struct v850_fixup fixups
[MAX_INSN_FIXUPS
];
101 struct v850_seg_entry v850_seg_table
[] =
104 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
107 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
},
109 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
},
111 SEC_ALLOC
| SEC_SMALL_DATA
},
117 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_READONLY
| SEC_DATA
118 | SEC_HAS_CONTENTS
| SEC_SMALL_DATA
},
120 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_READONLY
| SEC_DATA
121 | SEC_HAS_CONTENTS
},
123 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
124 | SEC_SMALL_DATA
| SEC_IS_COMMON
},
126 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
129 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
131 { NULL
, ".call_table_data",
132 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
| SEC_HAS_CONTENTS
},
133 { NULL
, ".call_table_text",
134 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_READONLY
| SEC_CODE
140 #define SDATA_SECTION 0
141 #define TDATA_SECTION 1
142 #define ZDATA_SECTION 2
143 #define SBSS_SECTION 3
144 #define TBSS_SECTION 4
145 #define ZBSS_SECTION 5
146 #define ROSDATA_SECTION 6
147 #define ROZDATA_SECTION 7
148 #define SCOMMON_SECTION 8
149 #define TCOMMON_SECTION 9
150 #define ZCOMMON_SECTION 10
151 #define CALL_TABLE_DATA_SECTION 11
152 #define CALL_TABLE_TEXT_SECTION 12
153 #define BSS_SECTION 13
155 static void do_v850_seg
PARAMS ((int, subsegT
));
162 struct v850_seg_entry
*seg
= v850_seg_table
+ i
;
164 obj_elf_section_change_hook ();
167 subseg_set (seg
->s
, sub
);
171 seg
->s
= subseg_new (seg
->name
, sub
);
172 bfd_set_section_flags (stdoutput
, seg
->s
, seg
->flags
);
173 if ((seg
->flags
& SEC_LOAD
) == 0)
174 seg_info (seg
->s
)->bss
= 1;
178 static void v850_seg
PARAMS ((int i
));
184 subsegT sub
= get_absolute_expression ();
186 do_v850_seg (i
, sub
);
187 demand_empty_rest_of_line ();
190 static void v850_offset
PARAMS ((int));
194 int ignore ATTRIBUTE_UNUSED
;
197 int temp
= get_absolute_expression ();
199 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, (symbolS
*)0,
200 (offsetT
) temp
, (char *) 0);
203 demand_empty_rest_of_line ();
206 /* Copied from obj_elf_common() in gas/config/obj-elf.c. */
208 static void v850_comm
PARAMS ((int));
222 name
= input_line_pointer
;
223 c
= get_symbol_end ();
225 /* Just after name is now '\0'. */
226 p
= input_line_pointer
;
231 if (*input_line_pointer
!= ',')
233 as_bad (_("Expected comma after symbol-name"));
234 ignore_rest_of_line ();
239 input_line_pointer
++;
241 if ((temp
= get_absolute_expression ()) < 0)
243 /* xgettext:c-format */
244 as_bad (_(".COMMon length (%d.) < 0! Ignored."), temp
);
245 ignore_rest_of_line ();
251 symbolP
= symbol_find_or_make (name
);
254 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
256 as_bad (_("Ignoring attempt to re-define symbol"));
257 ignore_rest_of_line ();
261 if (S_GET_VALUE (symbolP
) != 0)
263 if (S_GET_VALUE (symbolP
) != size
)
265 /* xgettext:c-format */
266 as_warn (_("Length of .comm \"%s\" is already %ld. Not changed to %d."),
267 S_GET_NAME (symbolP
), (long) S_GET_VALUE (symbolP
), size
);
271 know (symbol_get_frag (symbolP
) == &zero_address_frag
);
273 if (*input_line_pointer
!= ',')
278 input_line_pointer
++;
282 if (! have_align
|| *input_line_pointer
!= '"')
288 temp
= get_absolute_expression ();
293 as_warn (_("Common alignment negative; 0 assumed"));
297 if (symbol_get_obj (symbolP
)->local
)
306 old_subsec
= now_subseg
;
308 applicable
= bfd_applicable_section_flags (stdoutput
);
310 applicable
&= SEC_ALLOC
;
314 case SCOMMON_SECTION
:
315 do_v850_seg (SBSS_SECTION
, 0);
318 case ZCOMMON_SECTION
:
319 do_v850_seg (ZBSS_SECTION
, 0);
322 case TCOMMON_SECTION
:
323 do_v850_seg (TBSS_SECTION
, 0);
329 /* Convert to a power of 2 alignment. */
330 for (align
= 0; (temp
& 1) == 0; temp
>>= 1, ++align
)
335 as_bad (_("Common alignment not a power of 2"));
336 ignore_rest_of_line ();
343 record_alignment (now_seg
, align
);
346 frag_align (align
, 0, 0);
350 case SCOMMON_SECTION
:
351 if (S_GET_SEGMENT (symbolP
) == v850_seg_table
[SBSS_SECTION
].s
)
352 symbol_get_frag (symbolP
)->fr_symbol
= 0;
355 case ZCOMMON_SECTION
:
356 if (S_GET_SEGMENT (symbolP
) == v850_seg_table
[ZBSS_SECTION
].s
)
357 symbol_get_frag (symbolP
)->fr_symbol
= 0;
360 case TCOMMON_SECTION
:
361 if (S_GET_SEGMENT (symbolP
) == v850_seg_table
[TBSS_SECTION
].s
)
362 symbol_get_frag (symbolP
)->fr_symbol
= 0;
369 symbol_set_frag (symbolP
, frag_now
);
370 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
,
371 (offsetT
) size
, (char *) 0);
373 S_SET_SIZE (symbolP
, size
);
377 case SCOMMON_SECTION
:
378 S_SET_SEGMENT (symbolP
, v850_seg_table
[SBSS_SECTION
].s
);
381 case ZCOMMON_SECTION
:
382 S_SET_SEGMENT (symbolP
, v850_seg_table
[ZBSS_SECTION
].s
);
385 case TCOMMON_SECTION
:
386 S_SET_SEGMENT (symbolP
, v850_seg_table
[TBSS_SECTION
].s
);
393 S_CLEAR_EXTERNAL (symbolP
);
394 obj_elf_section_change_hook ();
395 subseg_set (old_sec
, old_subsec
);
404 old_subsec
= now_subseg
;
406 S_SET_VALUE (symbolP
, (valueT
) size
);
407 S_SET_ALIGN (symbolP
, temp
);
408 S_SET_EXTERNAL (symbolP
);
412 case SCOMMON_SECTION
:
413 case ZCOMMON_SECTION
:
414 case TCOMMON_SECTION
:
415 do_v850_seg (area
, 0);
416 S_SET_SEGMENT (symbolP
, v850_seg_table
[area
].s
);
423 obj_elf_section_change_hook ();
424 subseg_set (old_sec
, old_subsec
);
429 input_line_pointer
++;
431 /* @@ Some use the dot, some don't. Can we get some consistency?? */
432 if (*input_line_pointer
== '.')
433 input_line_pointer
++;
435 /* @@ Some say data, some say bss. */
436 if (strncmp (input_line_pointer
, "bss\"", 4)
437 && strncmp (input_line_pointer
, "data\"", 5))
439 while (*--input_line_pointer
!= '"')
441 input_line_pointer
--;
442 goto bad_common_segment
;
444 while (*input_line_pointer
++ != '"')
446 goto allocate_common
;
449 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
451 demand_empty_rest_of_line ();
456 p
= input_line_pointer
;
457 while (*p
&& *p
!= '\n')
461 as_bad (_("bad .common segment %s"), input_line_pointer
+ 1);
463 input_line_pointer
= p
;
464 ignore_rest_of_line ();
469 static void set_machine
PARAMS ((int));
476 bfd_set_arch_mach (stdoutput
, TARGET_ARCH
, machine
);
480 case 0: processor_mask
= PROCESSOR_V850
; break;
481 case bfd_mach_v850e
: processor_mask
= PROCESSOR_V850E
; break;
485 static void v850_longcode
PARAMS ((int));
496 as_warn (".longcall pseudo-op seen when not relaxing");
498 as_warn (".longjump pseudo-op seen when not relaxing");
503 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
505 as_bad ("bad .longcall format");
506 ignore_rest_of_line ();
512 fix_new_exp (frag_now
, frag_now_fix (), 4, & ex
, 1,
513 BFD_RELOC_V850_LONGCALL
);
515 fix_new_exp (frag_now
, frag_now_fix (), 4, & ex
, 1,
516 BFD_RELOC_V850_LONGJUMP
);
518 demand_empty_rest_of_line ();
521 /* The target specific pseudo-ops which we support. */
522 const pseudo_typeS md_pseudo_table
[] =
524 { "sdata", v850_seg
, SDATA_SECTION
},
525 { "tdata", v850_seg
, TDATA_SECTION
},
526 { "zdata", v850_seg
, ZDATA_SECTION
},
527 { "sbss", v850_seg
, SBSS_SECTION
},
528 { "tbss", v850_seg
, TBSS_SECTION
},
529 { "zbss", v850_seg
, ZBSS_SECTION
},
530 { "rosdata", v850_seg
, ROSDATA_SECTION
},
531 { "rozdata", v850_seg
, ROZDATA_SECTION
},
532 { "bss", v850_seg
, BSS_SECTION
},
533 { "offset", v850_offset
, 0 },
535 { "zcomm", v850_comm
, ZCOMMON_SECTION
},
536 { "scomm", v850_comm
, SCOMMON_SECTION
},
537 { "tcomm", v850_comm
, TCOMMON_SECTION
},
538 { "v850", set_machine
, 0 },
539 { "call_table_data", v850_seg
, CALL_TABLE_DATA_SECTION
},
540 { "call_table_text", v850_seg
, CALL_TABLE_TEXT_SECTION
},
541 { "v850e", set_machine
, bfd_mach_v850e
},
542 { "longcall", v850_longcode
, 1 },
543 { "longjump", v850_longcode
, 2 },
547 /* Opcode hash table. */
548 static struct hash_control
*v850_hash
;
550 /* This table is sorted. Suitable for searching by a binary search. */
551 static const struct reg_name pre_defined_registers
[] =
553 { "ep", 30 }, /* ep - element ptr */
554 { "gp", 4 }, /* gp - global ptr */
555 { "hp", 2 }, /* hp - handler stack ptr */
556 { "lp", 31 }, /* lp - link ptr */
589 { "sp", 3 }, /* sp - stack ptr */
590 { "tp", 5 }, /* tp - text ptr */
594 #define REG_NAME_CNT \
595 (sizeof (pre_defined_registers) / sizeof (struct reg_name))
597 static const struct reg_name system_registers
[] =
619 #define SYSREG_NAME_CNT \
620 (sizeof (system_registers) / sizeof (struct reg_name))
622 static const struct reg_name system_list_registers
[] =
628 #define SYSREGLIST_NAME_CNT \
629 (sizeof (system_list_registers) / sizeof (struct reg_name))
631 static const struct reg_name cc_names
[] =
657 #define CC_NAME_CNT \
658 (sizeof (cc_names) / sizeof (struct reg_name))
660 /* Do a binary search of the given register table to see if NAME is a
661 valid regiter name. Return the register number from the array on
662 success, or -1 on failure. */
664 static int reg_name_search
665 PARAMS ((const struct reg_name
*, int, const char *, bfd_boolean
));
668 reg_name_search (regs
, regcount
, name
, accept_numbers
)
669 const struct reg_name
*regs
;
672 bfd_boolean accept_numbers
;
674 int middle
, low
, high
;
678 /* If the register name is a symbol, then evaluate it. */
679 if ((symbolP
= symbol_find (name
)) != NULL
)
681 /* If the symbol is an alias for another name then use that.
682 If the symbol is an alias for a number, then return the number. */
683 if (symbol_equated_p (symbolP
))
686 = S_GET_NAME (symbol_get_value_expression (symbolP
)->X_add_symbol
);
688 else if (accept_numbers
)
690 int reg
= S_GET_VALUE (symbolP
);
692 if (reg
>= 0 && reg
<= 31)
696 /* Otherwise drop through and try parsing name normally. */
704 middle
= (low
+ high
) / 2;
705 cmp
= strcasecmp (name
, regs
[middle
].name
);
711 return regs
[middle
].value
;
717 /* Summary of register_name().
719 in: Input_line_pointer points to 1st char of operand.
722 The operand may have been a register: in this case, X_op == O_register,
723 X_add_number is set to the register number, and truth is returned.
724 Input_line_pointer->(next non-blank) char after operand, or is in
725 its original state. */
727 static bfd_boolean register_name
PARAMS ((expressionS
*));
730 register_name (expressionP
)
731 expressionS
*expressionP
;
738 /* Find the spelling of the operand. */
739 start
= name
= input_line_pointer
;
741 c
= get_symbol_end ();
743 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
,
746 /* Put back the delimiting char. */
747 *input_line_pointer
= c
;
749 /* Look to see if it's in the register table. */
752 expressionP
->X_op
= O_register
;
753 expressionP
->X_add_number
= reg_number
;
755 /* Make the rest nice. */
756 expressionP
->X_add_symbol
= NULL
;
757 expressionP
->X_op_symbol
= NULL
;
763 /* Reset the line as if we had not done anything. */
764 input_line_pointer
= start
;
770 /* Summary of system_register_name().
772 in: INPUT_LINE_POINTER points to 1st char of operand.
773 EXPRESSIONP points to an expression structure to be filled in.
774 ACCEPT_NUMBERS is true iff numerical register names may be used.
775 ACCEPT_LIST_NAMES is true iff the special names PS and SR may be
778 out: An expressionS structure in expressionP.
779 The operand may have been a register: in this case, X_op == O_register,
780 X_add_number is set to the register number, and truth is returned.
781 Input_line_pointer->(next non-blank) char after operand, or is in
782 its original state. */
784 static bfd_boolean system_register_name
785 PARAMS ((expressionS
*, bfd_boolean
, bfd_boolean
));
788 system_register_name (expressionP
, accept_numbers
, accept_list_names
)
789 expressionS
*expressionP
;
790 bfd_boolean accept_numbers
;
791 bfd_boolean accept_list_names
;
798 /* Find the spelling of the operand. */
799 start
= name
= input_line_pointer
;
801 c
= get_symbol_end ();
802 reg_number
= reg_name_search (system_registers
, SYSREG_NAME_CNT
, name
,
805 /* Put back the delimiting char. */
806 *input_line_pointer
= c
;
811 /* Reset input_line pointer. */
812 input_line_pointer
= start
;
814 if (ISDIGIT (*input_line_pointer
))
816 reg_number
= strtol (input_line_pointer
, &input_line_pointer
, 10);
818 /* Make sure that the register number is allowable. */
820 || (reg_number
> 5 && reg_number
< 16)
826 else if (accept_list_names
)
828 c
= get_symbol_end ();
829 reg_number
= reg_name_search (system_list_registers
,
830 SYSREGLIST_NAME_CNT
, name
, FALSE
);
832 /* Put back the delimiting char. */
833 *input_line_pointer
= c
;
837 /* Look to see if it's in the register table. */
840 expressionP
->X_op
= O_register
;
841 expressionP
->X_add_number
= reg_number
;
843 /* Make the rest nice. */
844 expressionP
->X_add_symbol
= NULL
;
845 expressionP
->X_op_symbol
= NULL
;
851 /* Reset the line as if we had not done anything. */
852 input_line_pointer
= start
;
858 /* Summary of cc_name().
860 in: INPUT_LINE_POINTER points to 1st char of operand.
863 The operand may have been a register: in this case, X_op == O_register,
864 X_add_number is set to the register number, and truth is returned.
865 Input_line_pointer->(next non-blank) char after operand, or is in
866 its original state. */
868 static bfd_boolean cc_name
PARAMS ((expressionS
*));
871 cc_name (expressionP
)
872 expressionS
*expressionP
;
879 /* Find the spelling of the operand. */
880 start
= name
= input_line_pointer
;
882 c
= get_symbol_end ();
883 reg_number
= reg_name_search (cc_names
, CC_NAME_CNT
, name
, FALSE
);
885 /* Put back the delimiting char. */
886 *input_line_pointer
= c
;
888 /* Look to see if it's in the register table. */
891 expressionP
->X_op
= O_constant
;
892 expressionP
->X_add_number
= reg_number
;
894 /* Make the rest nice. */
895 expressionP
->X_add_symbol
= NULL
;
896 expressionP
->X_op_symbol
= NULL
;
902 /* Reset the line as if we had not done anything. */
903 input_line_pointer
= start
;
909 static void skip_white_space
PARAMS ((void));
914 while (*input_line_pointer
== ' '
915 || *input_line_pointer
== '\t')
916 ++input_line_pointer
;
919 /* Summary of parse_register_list ().
921 in: INPUT_LINE_POINTER points to 1st char of a list of registers.
922 INSN is the partially constructed instruction.
923 OPERAND is the operand being inserted.
925 out: NULL if the parse completed successfully, otherwise a
926 pointer to an error message is returned. If the parse
927 completes the correct bit fields in the instruction
930 Parses register lists with the syntax:
938 and also parses constant epxressions whoes bits indicate the
939 registers in the lists. The LSB in the expression refers to
940 the lowest numbered permissable register in the register list,
941 and so on upwards. System registers are considered to be very
944 static char *parse_register_list
945 PARAMS ((unsigned long *, const struct v850_operand
*));
948 parse_register_list (insn
, operand
)
950 const struct v850_operand
*operand
;
952 static int type1_regs
[32] = {
953 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
954 0, 0, 0, 0, 0, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
956 static int type2_regs
[32] = {
957 19, 18, 17, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
958 0, 0, 0, 0, 30, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
960 static int type3_regs
[32] = {
961 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
962 0, 0, 0, 0, 14, 15, 13, 12, 7, 6, 5, 4, 11, 10, 9, 8
967 /* Select a register array to parse. */
968 switch (operand
->shift
)
970 case 0xffe00001: regs
= type1_regs
; break;
971 case 0xfff8000f: regs
= type2_regs
; break;
972 case 0xfff8001f: regs
= type3_regs
; break;
974 as_bad (_("unknown operand shift: %x\n"), operand
->shift
);
975 return _("internal failure in parse_register_list");
980 /* If the expression starts with a curly brace it is a register list.
981 Otherwise it is a constant expression, whoes bits indicate which
982 registers are to be included in the list. */
983 if (*input_line_pointer
!= '{')
990 if (exp
.X_op
!= O_constant
)
991 return _("constant expression or register list expected");
993 if (regs
== type1_regs
)
995 if (exp
.X_add_number
& 0xFFFFF000)
996 return _("high bits set in register list expression");
998 for (reg
= 20; reg
< 32; reg
++)
999 if (exp
.X_add_number
& (1 << (reg
- 20)))
1001 for (i
= 0; i
< 32; i
++)
1006 else if (regs
== type2_regs
)
1008 if (exp
.X_add_number
& 0xFFFE0000)
1009 return _("high bits set in register list expression");
1011 for (reg
= 1; reg
< 16; reg
++)
1012 if (exp
.X_add_number
& (1 << (reg
- 1)))
1014 for (i
= 0; i
< 32; i
++)
1019 if (exp
.X_add_number
& (1 << 15))
1022 if (exp
.X_add_number
& (1 << 16))
1025 else /* regs == type3_regs */
1027 if (exp
.X_add_number
& 0xFFFE0000)
1028 return _("high bits set in register list expression");
1030 for (reg
= 16; reg
< 32; reg
++)
1031 if (exp
.X_add_number
& (1 << (reg
- 16)))
1033 for (i
= 0; i
< 32; i
++)
1038 if (exp
.X_add_number
& (1 << 16))
1045 input_line_pointer
++;
1047 /* Parse the register list until a terminator (closing curly brace or
1048 new-line) is found. */
1051 if (register_name (&exp
))
1055 /* Locate the given register in the list, and if it is there,
1056 insert the corresponding bit into the instruction. */
1057 for (i
= 0; i
< 32; i
++)
1059 if (regs
[i
] == exp
.X_add_number
)
1067 return _("illegal register included in list");
1069 else if (system_register_name (&exp
, TRUE
, TRUE
))
1071 if (regs
== type1_regs
)
1073 return _("system registers cannot be included in list");
1075 else if (exp
.X_add_number
== 5)
1077 if (regs
== type2_regs
)
1078 return _("PSW cannot be included in list");
1082 else if (exp
.X_add_number
< 4)
1085 return _("High value system registers cannot be included in list");
1087 else if (*input_line_pointer
== '}')
1089 input_line_pointer
++;
1092 else if (*input_line_pointer
== ',')
1094 input_line_pointer
++;
1097 else if (*input_line_pointer
== '-')
1099 /* We have encountered a range of registers: rX - rY. */
1103 /* Skip the dash. */
1104 ++input_line_pointer
;
1106 /* Get the second register in the range. */
1107 if (! register_name (&exp2
))
1109 return _("second register should follow dash in register list");
1110 exp2
.X_add_number
= exp
.X_add_number
;
1113 /* Add the rest of the registers in the range. */
1114 for (j
= exp
.X_add_number
+ 1; j
<= exp2
.X_add_number
; j
++)
1118 /* Locate the given register in the list, and if it is there,
1119 insert the corresponding bit into the instruction. */
1120 for (i
= 0; i
< 32; i
++)
1130 return _("illegal register included in list");
1136 skip_white_space ();
1142 const char *md_shortopts
= "m:";
1144 struct option md_longopts
[] = {
1145 {NULL
, no_argument
, NULL
, 0}
1148 size_t md_longopts_size
= sizeof (md_longopts
);
1151 md_show_usage (stream
)
1154 fprintf (stream
, _(" V850 options:\n"));
1155 fprintf (stream
, _(" -mwarn-signed-overflow Warn if signed immediate values overflow\n"));
1156 fprintf (stream
, _(" -mwarn-unsigned-overflow Warn if unsigned immediate values overflow\n"));
1157 fprintf (stream
, _(" -mv850 The code is targeted at the v850\n"));
1158 fprintf (stream
, _(" -mv850e The code is targeted at the v850e\n"));
1159 fprintf (stream
, _(" -mv850any The code is generic, despite any processor specific instructions\n"));
1160 fprintf (stream
, _(" -mrelax Enable relaxation\n"));
1164 md_parse_option (c
, arg
)
1171 /* xgettext:c-format */
1172 fprintf (stderr
, _("unknown command line option: -%c%s\n"), c
, arg
);
1176 if (strcmp (arg
, "warn-signed-overflow") == 0)
1178 warn_signed_overflows
= TRUE
;
1180 else if (strcmp (arg
, "warn-unsigned-overflow") == 0)
1182 warn_unsigned_overflows
= TRUE
;
1184 else if (strcmp (arg
, "v850") == 0)
1187 processor_mask
= PROCESSOR_V850
;
1189 else if (strcmp (arg
, "v850e") == 0)
1191 machine
= bfd_mach_v850e
;
1192 processor_mask
= PROCESSOR_V850E
;
1194 else if (strcmp (arg
, "v850any") == 0)
1196 /* Tell the world that this is for any v850 chip. */
1199 /* But support instructions for the extended versions. */
1200 processor_mask
= PROCESSOR_V850E
;
1202 else if (strcmp (arg
, "relax") == 0)
1206 /* xgettext:c-format */
1207 fprintf (stderr
, _("unknown command line option: -%c%s\n"), c
, arg
);
1215 md_undefined_symbol (name
)
1216 char *name ATTRIBUTE_UNUSED
;
1222 md_atof (type
, litp
, sizep
)
1228 LITTLENUM_TYPE words
[4];
1244 return _("bad call to md_atof");
1247 t
= atof_ieee (input_line_pointer
, type
, words
);
1249 input_line_pointer
= t
;
1253 for (i
= prec
- 1; i
>= 0; i
--)
1255 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
1265 md_convert_frag (abfd
, sec
, fragP
)
1266 bfd
*abfd ATTRIBUTE_UNUSED
;
1270 subseg_change (sec
, 0);
1272 /* In range conditional or unconditional branch. */
1273 if (fragP
->fr_subtype
== 0 || fragP
->fr_subtype
== 2)
1275 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
,
1276 fragP
->fr_offset
, 1, BFD_RELOC_UNUSED
+ (int)fragP
->fr_opcode
);
1279 /* Out of range conditional branch. Emit a branch around a jump. */
1280 else if (fragP
->fr_subtype
== 1)
1282 unsigned char *buffer
=
1283 (unsigned char *) (fragP
->fr_fix
+ fragP
->fr_literal
);
1285 /* Reverse the condition of the first branch. */
1287 /* Mask off all the displacement bits. */
1290 /* Now set the displacement bits so that we branch
1291 around the unconditional branch. */
1294 /* Now create the unconditional branch + fixup to the final
1296 md_number_to_chars (buffer
+ 2, 0x00000780, 4);
1297 fix_new (fragP
, fragP
->fr_fix
+ 2, 4, fragP
->fr_symbol
,
1298 fragP
->fr_offset
, 1, BFD_RELOC_UNUSED
+
1299 (int) fragP
->fr_opcode
+ 1);
1302 /* Out of range unconditional branch. Emit a jump. */
1303 else if (fragP
->fr_subtype
== 3)
1305 md_number_to_chars (fragP
->fr_fix
+ fragP
->fr_literal
, 0x00000780, 4);
1306 fix_new (fragP
, fragP
->fr_fix
, 4, fragP
->fr_symbol
,
1307 fragP
->fr_offset
, 1, BFD_RELOC_UNUSED
+
1308 (int) fragP
->fr_opcode
+ 1);
1316 md_section_align (seg
, addr
)
1320 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1321 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1327 char *prev_name
= "";
1328 const struct v850_opcode
*op
;
1330 if (strncmp (TARGET_CPU
, "v850e", 5) == 0)
1333 machine
= bfd_mach_v850e
;
1335 if (processor_mask
== -1)
1336 processor_mask
= PROCESSOR_V850E
;
1338 else if (strncmp (TARGET_CPU
, "v850", 4) == 0)
1343 if (processor_mask
== -1)
1344 processor_mask
= PROCESSOR_V850
;
1347 /* xgettext:c-format */
1348 as_bad (_("Unable to determine default target processor from string: %s"),
1351 v850_hash
= hash_new ();
1353 /* Insert unique names into hash table. The V850 instruction set
1354 has many identical opcode names that have different opcodes based
1355 on the operands. This hash table then provides a quick index to
1356 the first opcode with a particular name in the opcode table. */
1360 if (strcmp (prev_name
, op
->name
))
1362 prev_name
= (char *) op
->name
;
1363 hash_insert (v850_hash
, op
->name
, (char *) op
);
1368 v850_seg_table
[BSS_SECTION
].s
= bss_section
;
1369 bfd_set_arch_mach (stdoutput
, TARGET_ARCH
, machine
);
1372 static bfd_reloc_code_real_type handle_ctoff
1373 PARAMS ((const struct v850_operand
*));
1375 static bfd_reloc_code_real_type
1376 handle_ctoff (operand
)
1377 const struct v850_operand
*operand
;
1379 if (operand
== NULL
)
1380 return BFD_RELOC_V850_CALLT_16_16_OFFSET
;
1382 if (operand
->bits
!= 6
1383 || operand
->shift
!= 0)
1385 as_bad (_("ctoff() relocation used on an instruction which does not support it"));
1386 return BFD_RELOC_64
; /* Used to indicate an error condition. */
1389 return BFD_RELOC_V850_CALLT_6_7_OFFSET
;
1392 static bfd_reloc_code_real_type handle_sdaoff
1393 PARAMS ((const struct v850_operand
*));
1395 static bfd_reloc_code_real_type
1396 handle_sdaoff (operand
)
1397 const struct v850_operand
*operand
;
1399 if (operand
== NULL
)
1400 return BFD_RELOC_V850_SDA_16_16_OFFSET
;
1402 if (operand
->bits
== 15 && operand
->shift
== 17)
1403 return BFD_RELOC_V850_SDA_15_16_OFFSET
;
1405 if (operand
->bits
== -1)
1406 return BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
;
1408 if (operand
->bits
!= 16
1409 || operand
->shift
!= 16)
1411 as_bad (_("sdaoff() relocation used on an instruction which does not support it"));
1412 return BFD_RELOC_64
; /* Used to indicate an error condition. */
1415 return BFD_RELOC_V850_SDA_16_16_OFFSET
;
1418 static bfd_reloc_code_real_type handle_zdaoff
1419 PARAMS ((const struct v850_operand
*));
1421 static bfd_reloc_code_real_type
1422 handle_zdaoff (operand
)
1423 const struct v850_operand
*operand
;
1425 if (operand
== NULL
)
1426 return BFD_RELOC_V850_ZDA_16_16_OFFSET
;
1428 if (operand
->bits
== 15 && operand
->shift
== 17)
1429 return BFD_RELOC_V850_ZDA_15_16_OFFSET
;
1431 if (operand
->bits
== -1)
1432 return BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
;
1434 if (operand
->bits
!= 16
1435 || operand
->shift
!= 16)
1437 as_bad (_("zdaoff() relocation used on an instruction which does not support it"));
1438 /* Used to indicate an error condition. */
1439 return BFD_RELOC_64
;
1442 return BFD_RELOC_V850_ZDA_16_16_OFFSET
;
1445 static bfd_reloc_code_real_type handle_tdaoff
1446 PARAMS ((const struct v850_operand
*));
1448 static bfd_reloc_code_real_type
1449 handle_tdaoff (operand
)
1450 const struct v850_operand
*operand
;
1452 if (operand
== NULL
)
1453 /* Data item, not an instruction. */
1454 return BFD_RELOC_V850_TDA_7_7_OFFSET
;
1456 if (operand
->bits
== 6 && operand
->shift
== 1)
1457 /* sld.w/sst.w, operand: D8_6 */
1458 return BFD_RELOC_V850_TDA_6_8_OFFSET
;
1460 if (operand
->bits
== 4 && operand
->insert
!= NULL
)
1461 /* sld.hu, operand: D5-4 */
1462 return BFD_RELOC_V850_TDA_4_5_OFFSET
;
1464 if (operand
->bits
== 4 && operand
->insert
== NULL
)
1465 /* sld.bu, operand: D4 */
1466 return BFD_RELOC_V850_TDA_4_4_OFFSET
;
1468 if (operand
->bits
== 16 && operand
->shift
== 16)
1469 /* set1 & chums, operands: D16 */
1470 return BFD_RELOC_V850_TDA_16_16_OFFSET
;
1472 if (operand
->bits
!= 7)
1474 as_bad (_("tdaoff() relocation used on an instruction which does not support it"));
1475 /* Used to indicate an error condition. */
1476 return BFD_RELOC_64
;
1479 return operand
->insert
!= NULL
1480 ? BFD_RELOC_V850_TDA_7_8_OFFSET
/* sld.h/sst.h, operand: D8_7 */
1481 : BFD_RELOC_V850_TDA_7_7_OFFSET
; /* sld.b/sst.b, opreand: D7 */
1484 /* Warning: The code in this function relies upon the definitions
1485 in the v850_operands[] array (defined in opcodes/v850-opc.c)
1486 matching the hard coded values contained herein. */
1488 static bfd_reloc_code_real_type v850_reloc_prefix
1489 PARAMS ((const struct v850_operand
*));
1491 static bfd_reloc_code_real_type
1492 v850_reloc_prefix (operand
)
1493 const struct v850_operand
*operand
;
1495 bfd_boolean paren_skipped
= FALSE
;
1497 /* Skip leading opening parenthesis. */
1498 if (*input_line_pointer
== '(')
1500 ++input_line_pointer
;
1501 paren_skipped
= TRUE
;
1504 #define CHECK_(name, reloc) \
1505 if (strncmp (input_line_pointer, name "(", strlen (name) + 1) == 0) \
1507 input_line_pointer += strlen (name); \
1511 CHECK_ ("hi0", BFD_RELOC_HI16
);
1512 CHECK_ ("hi", BFD_RELOC_HI16_S
);
1513 CHECK_ ("lo", BFD_RELOC_LO16
);
1514 CHECK_ ("sdaoff", handle_sdaoff (operand
));
1515 CHECK_ ("zdaoff", handle_zdaoff (operand
));
1516 CHECK_ ("tdaoff", handle_tdaoff (operand
));
1517 CHECK_ ("hilo", BFD_RELOC_32
);
1518 CHECK_ ("ctoff", handle_ctoff (operand
) );
1520 /* Restore skipped parenthesis. */
1522 --input_line_pointer
;
1524 return BFD_RELOC_UNUSED
;
1527 /* Insert an operand value into an instruction. */
1529 static unsigned long v850_insert_operand
1530 PARAMS ((unsigned long, const struct v850_operand
*, offsetT
, char *,
1531 unsigned int, char *));
1533 static unsigned long
1534 v850_insert_operand (insn
, operand
, val
, file
, line
, str
)
1536 const struct v850_operand
*operand
;
1542 if (operand
->insert
)
1544 const char *message
= NULL
;
1546 insn
= operand
->insert (insn
, val
, &message
);
1547 if (message
!= NULL
)
1549 if ((operand
->flags
& V850_OPERAND_SIGNED
)
1550 && ! warn_signed_overflows
1551 && strstr (message
, "out of range") != NULL
)
1553 /* Skip warning... */
1555 else if ((operand
->flags
& V850_OPERAND_SIGNED
) == 0
1556 && ! warn_unsigned_overflows
1557 && strstr (message
, "out of range") != NULL
)
1559 /* Skip warning... */
1563 if (file
== (char *) NULL
)
1564 as_warn ("%s: %s", str
, message
);
1566 as_warn_where (file
, line
, "%s: %s", str
, message
);
1570 if (file
== (char *) NULL
)
1573 as_warn_where (file
, line
, message
);
1579 if (operand
->bits
!= 32)
1583 if ((operand
->flags
& V850_OPERAND_SIGNED
) != 0)
1585 if (! warn_signed_overflows
)
1586 max
= (1 << operand
->bits
) - 1;
1588 max
= (1 << (operand
->bits
- 1)) - 1;
1590 min
= -(1 << (operand
->bits
- 1));
1594 max
= (1 << operand
->bits
) - 1;
1596 if (! warn_unsigned_overflows
)
1597 min
= -(1 << (operand
->bits
- 1));
1602 if (val
< (offsetT
) min
|| val
> (offsetT
) max
)
1604 /* xgettext:c-format */
1606 _("operand out of range (%s not between %ld and %ld)");
1609 /* Restore min and mix to expected values for decimal ranges. */
1610 if ((operand
->flags
& V850_OPERAND_SIGNED
)
1611 && ! warn_signed_overflows
)
1612 max
= (1 << (operand
->bits
- 1)) - 1;
1614 if (! (operand
->flags
& V850_OPERAND_SIGNED
)
1615 && ! warn_unsigned_overflows
)
1620 sprintf (buf
, "%s: ", str
);
1622 sprint_value (buf
+ strlen (buf
), val
);
1625 sprint_value (buf
, val
);
1627 if (file
== (char *) NULL
)
1628 as_warn (err
, buf
, min
, max
);
1630 as_warn_where (file
, line
, err
, buf
, min
, max
);
1634 insn
|= (((long) val
& ((1 << operand
->bits
) - 1)) << operand
->shift
);
1640 static char copy_of_instruction
[128];
1647 char *start_of_operands
;
1648 struct v850_opcode
*opcode
;
1649 struct v850_opcode
*next_opcode
;
1650 const unsigned char *opindex_ptr
;
1654 unsigned long insn_size
;
1658 bfd_boolean extra_data_after_insn
= FALSE
;
1659 unsigned extra_data_len
= 0;
1660 unsigned long extra_data
= 0;
1661 char *saved_input_line_pointer
;
1663 strncpy (copy_of_instruction
, str
, sizeof (copy_of_instruction
) - 1);
1665 /* Get the opcode. */
1666 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1672 /* Find the first opcode with the proper name. */
1673 opcode
= (struct v850_opcode
*) hash_find (v850_hash
, str
);
1676 /* xgettext:c-format */
1677 as_bad (_("Unrecognized opcode: `%s'"), str
);
1678 ignore_rest_of_line ();
1683 while (ISSPACE (*str
))
1686 start_of_operands
= str
;
1688 saved_input_line_pointer
= input_line_pointer
;
1692 const char *errmsg
= NULL
;
1696 if ((opcode
->processors
& processor_mask
) == 0)
1698 errmsg
= _("Target processor does not support this instruction.");
1705 insn
= opcode
->opcode
;
1706 extra_data_after_insn
= FALSE
;
1708 input_line_pointer
= str
= start_of_operands
;
1710 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1712 const struct v850_operand
*operand
;
1715 bfd_reloc_code_real_type reloc
;
1717 if (next_opindex
== 0)
1719 operand
= &v850_operands
[*opindex_ptr
];
1723 operand
= &v850_operands
[next_opindex
];
1729 while (*str
== ' ' || *str
== ',' || *str
== '[' || *str
== ']')
1732 if (operand
->flags
& V850_OPERAND_RELAX
)
1735 /* Gather the operand. */
1736 hold
= input_line_pointer
;
1737 input_line_pointer
= str
;
1739 /* lo(), hi(), hi0(), etc... */
1740 if ((reloc
= v850_reloc_prefix (operand
)) != BFD_RELOC_UNUSED
)
1742 /* This is a fake reloc, used to indicate an error condition. */
1743 if (reloc
== BFD_RELOC_64
)
1751 if (ex
.X_op
== O_constant
)
1755 case BFD_RELOC_V850_ZDA_16_16_OFFSET
:
1756 /* To cope with "not1 7, zdaoff(0xfffff006)[r0]"
1760 case BFD_RELOC_LO16
:
1762 /* Truncate, then sign extend the value. */
1763 ex
.X_add_number
= SEXT16 (ex
.X_add_number
);
1767 case BFD_RELOC_HI16
:
1769 /* Truncate, then sign extend the value. */
1770 ex
.X_add_number
= SEXT16 (ex
.X_add_number
>> 16);
1774 case BFD_RELOC_HI16_S
:
1776 /* Truncate, then sign extend the value. */
1777 int temp
= (ex
.X_add_number
>> 16) & 0xffff;
1779 temp
+= (ex
.X_add_number
>> 15) & 1;
1781 ex
.X_add_number
= SEXT16 (temp
);
1786 if ((operand
->flags
& V850E_IMMEDIATE32
) == 0)
1788 errmsg
= _("immediate operand is too large");
1792 extra_data_after_insn
= TRUE
;
1798 fprintf (stderr
, "reloc: %d\n", reloc
);
1799 as_bad (_("AAARG -> unhandled constant reloc"));
1803 if (fc
> MAX_INSN_FIXUPS
)
1804 as_fatal (_("too many fixups"));
1806 fixups
[fc
].exp
= ex
;
1807 fixups
[fc
].opindex
= *opindex_ptr
;
1808 fixups
[fc
].reloc
= reloc
;
1813 if (reloc
== BFD_RELOC_32
)
1815 if ((operand
->flags
& V850E_IMMEDIATE32
) == 0)
1817 errmsg
= _("immediate operand is too large");
1821 extra_data_after_insn
= TRUE
;
1823 extra_data
= ex
.X_add_number
;
1826 if (fc
> MAX_INSN_FIXUPS
)
1827 as_fatal (_("too many fixups"));
1829 fixups
[fc
].exp
= ex
;
1830 fixups
[fc
].opindex
= *opindex_ptr
;
1831 fixups
[fc
].reloc
= reloc
;
1839 if ((operand
->flags
& V850_OPERAND_REG
) != 0)
1841 if (!register_name (&ex
))
1843 errmsg
= _("invalid register name");
1845 else if ((operand
->flags
& V850_NOT_R0
)
1846 && ex
.X_add_number
== 0)
1848 errmsg
= _("register r0 cannot be used here");
1850 /* Force an error message to be generated by
1851 skipping over any following potential matches
1856 else if ((operand
->flags
& V850_OPERAND_SRG
) != 0)
1858 if (!system_register_name (&ex
, TRUE
, FALSE
))
1860 errmsg
= _("invalid system register name");
1863 else if ((operand
->flags
& V850_OPERAND_EP
) != 0)
1865 char *start
= input_line_pointer
;
1866 char c
= get_symbol_end ();
1868 if (strcmp (start
, "ep") != 0 && strcmp (start
, "r30") != 0)
1870 /* Put things back the way we found them. */
1871 *input_line_pointer
= c
;
1872 input_line_pointer
= start
;
1873 errmsg
= _("expected EP register");
1877 *input_line_pointer
= c
;
1878 str
= input_line_pointer
;
1879 input_line_pointer
= hold
;
1881 while (*str
== ' ' || *str
== ','
1882 || *str
== '[' || *str
== ']')
1886 else if ((operand
->flags
& V850_OPERAND_CC
) != 0)
1890 errmsg
= _("invalid condition code name");
1893 else if (operand
->flags
& V850E_PUSH_POP
)
1895 errmsg
= parse_register_list (&insn
, operand
);
1897 /* The parse_register_list() function has already done
1898 everything, so fake a dummy expression. */
1899 ex
.X_op
= O_constant
;
1900 ex
.X_add_number
= 0;
1902 else if (operand
->flags
& V850E_IMMEDIATE16
)
1906 if (ex
.X_op
!= O_constant
)
1907 errmsg
= _("constant expression expected");
1908 else if (ex
.X_add_number
& 0xffff0000)
1910 if (ex
.X_add_number
& 0xffff)
1911 errmsg
= _("constant too big to fit into instruction");
1912 else if ((insn
& 0x001fffc0) == 0x00130780)
1913 ex
.X_add_number
>>= 16;
1915 errmsg
= _("constant too big to fit into instruction");
1918 extra_data_after_insn
= TRUE
;
1920 extra_data
= ex
.X_add_number
;
1921 ex
.X_add_number
= 0;
1923 else if (operand
->flags
& V850E_IMMEDIATE32
)
1927 if (ex
.X_op
!= O_constant
)
1928 errmsg
= _("constant expression expected");
1930 extra_data_after_insn
= TRUE
;
1932 extra_data
= ex
.X_add_number
;
1933 ex
.X_add_number
= 0;
1935 else if (register_name (&ex
)
1936 && (operand
->flags
& V850_OPERAND_REG
) == 0)
1941 /* It is possible that an alias has been defined that
1942 matches a register name. For example the code may
1943 include a ".set ZERO, 0" directive, which matches
1944 the register name "zero". Attempt to reparse the
1945 field as an expression, and only complain if we
1946 cannot generate a constant. */
1948 input_line_pointer
= str
;
1950 c
= get_symbol_end ();
1952 if (symbol_find (str
) != NULL
)
1955 *input_line_pointer
= c
;
1956 input_line_pointer
= str
;
1960 if (ex
.X_op
!= O_constant
)
1962 /* If this register is actually occuring too early on
1963 the parsing of the instruction, (because another
1964 field is missing) then report this. */
1965 if (opindex_ptr
[1] != 0
1966 && (v850_operands
[opindex_ptr
[1]].flags
1967 & V850_OPERAND_REG
))
1968 errmsg
= _("syntax error: value is missing before the register name");
1970 errmsg
= _("syntax error: register not expected");
1972 /* If we created a symbol in the process of this
1973 test then delete it now, so that it will not
1974 be output with the real symbols... */
1976 && ex
.X_op
== O_symbol
)
1977 symbol_remove (ex
.X_add_symbol
,
1978 &symbol_rootP
, &symbol_lastP
);
1981 else if (system_register_name (&ex
, FALSE
, FALSE
)
1982 && (operand
->flags
& V850_OPERAND_SRG
) == 0)
1984 errmsg
= _("syntax error: system register not expected");
1986 else if (cc_name (&ex
)
1987 && (operand
->flags
& V850_OPERAND_CC
) == 0)
1989 errmsg
= _("syntax error: condition code not expected");
1995 If we are assembling a MOV instruction and the immediate
1996 value does not fit into the bits available then create a
1997 fake error so that the next MOV instruction will be
1998 selected. This one has a 32 bit immediate field. */
2000 if (((insn
& 0x07e0) == 0x0200)
2001 && operand
->bits
== 5 /* Do not match the CALLT instruction. */
2002 && ex
.X_op
== O_constant
2003 && (ex
.X_add_number
< (-(1 << (operand
->bits
- 1)))
2004 || ex
.X_add_number
> ((1 << (operand
->bits
- 1)) - 1)))
2005 errmsg
= _("immediate operand is too large");
2013 " insn: %x, operand %d, op: %d, add_number: %d\n",
2014 insn
, opindex_ptr
- opcode
->operands
,
2015 ex
.X_op
, ex
.X_add_number
);
2021 errmsg
= _("illegal operand");
2024 errmsg
= _("missing operand");
2028 & (V850_OPERAND_REG
| V850_OPERAND_SRG
)) == 0)
2030 errmsg
= _("invalid operand");
2033 insn
= v850_insert_operand (insn
, operand
, ex
.X_add_number
,
2035 copy_of_instruction
);
2039 insn
= v850_insert_operand (insn
, operand
, ex
.X_add_number
,
2041 copy_of_instruction
);
2045 /* We need to generate a fixup for this expression. */
2046 if (fc
>= MAX_INSN_FIXUPS
)
2047 as_fatal (_("too many fixups"));
2049 fixups
[fc
].exp
= ex
;
2050 fixups
[fc
].opindex
= *opindex_ptr
;
2051 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
2057 str
= input_line_pointer
;
2058 input_line_pointer
= hold
;
2060 while (*str
== ' ' || *str
== ',' || *str
== '[' || *str
== ']'
2069 next_opcode
= opcode
+ 1;
2070 if (next_opcode
->name
!= NULL
2071 && strcmp (next_opcode
->name
, opcode
->name
) == 0)
2073 opcode
= next_opcode
;
2075 /* Skip versions that are not supported by the target
2077 if ((opcode
->processors
& processor_mask
) == 0)
2083 as_bad ("%s: %s", copy_of_instruction
, errmsg
);
2085 if (*input_line_pointer
== ']')
2086 ++input_line_pointer
;
2088 ignore_rest_of_line ();
2089 input_line_pointer
= saved_input_line_pointer
;
2095 while (ISSPACE (*str
))
2099 /* xgettext:c-format */
2100 as_bad (_("junk at end of line: `%s'"), str
);
2102 input_line_pointer
= str
;
2104 /* Tie dwarf2 debug info to the address at the start of the insn.
2105 We can't do this after the insn has been output as the current
2106 frag may have been closed off. eg. by frag_var. */
2107 dwarf2_emit_insn (0);
2109 /* Write out the instruction. */
2111 if (relaxable
&& fc
> 0)
2116 if (!strcmp (opcode
->name
, "br"))
2118 f
= frag_var (rs_machine_dependent
, 4, 2, 2,
2119 fixups
[0].exp
.X_add_symbol
,
2120 fixups
[0].exp
.X_add_number
,
2121 (char *) fixups
[0].opindex
);
2122 md_number_to_chars (f
, insn
, insn_size
);
2123 md_number_to_chars (f
+ 2, 0, 2);
2127 f
= frag_var (rs_machine_dependent
, 6, 4, 0,
2128 fixups
[0].exp
.X_add_symbol
,
2129 fixups
[0].exp
.X_add_number
,
2130 (char *) fixups
[0].opindex
);
2131 md_number_to_chars (f
, insn
, insn_size
);
2132 md_number_to_chars (f
+ 2, 0, 4);
2137 /* Four byte insns have an opcode with the two high bits on. */
2138 if ((insn
& 0x0600) == 0x0600)
2143 /* Special case: 32 bit MOV. */
2144 if ((insn
& 0xffe0) == 0x0620)
2147 f
= frag_more (insn_size
);
2148 md_number_to_chars (f
, insn
, insn_size
);
2150 if (extra_data_after_insn
)
2152 f
= frag_more (extra_data_len
);
2153 md_number_to_chars (f
, extra_data
, extra_data_len
);
2155 extra_data_after_insn
= FALSE
;
2159 /* Create any fixups. At this point we do not use a
2160 bfd_reloc_code_real_type, but instead just use the
2161 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2162 handle fixups for any operand type, although that is admittedly
2163 not a very exciting feature. We pick a BFD reloc type in
2165 for (i
= 0; i
< fc
; i
++)
2167 const struct v850_operand
*operand
;
2168 bfd_reloc_code_real_type reloc
;
2170 operand
= &v850_operands
[fixups
[i
].opindex
];
2172 reloc
= fixups
[i
].reloc
;
2174 if (reloc
!= BFD_RELOC_UNUSED
)
2176 reloc_howto_type
*reloc_howto
=
2177 bfd_reloc_type_lookup (stdoutput
, reloc
);
2185 size
= bfd_get_reloc_size (reloc_howto
);
2187 /* XXX This will abort on an R_V850_8 reloc -
2188 is this reloc actually used? */
2189 if (size
!= 2 && size
!= 4)
2192 address
= (f
- frag_now
->fr_literal
) + insn_size
- size
;
2194 if (reloc
== BFD_RELOC_32
)
2197 fixP
= fix_new_exp (frag_now
, address
, size
,
2199 reloc_howto
->pc_relative
,
2204 case BFD_RELOC_LO16
:
2205 case BFD_RELOC_HI16
:
2206 case BFD_RELOC_HI16_S
:
2207 fixP
->fx_no_overflow
= 1;
2215 fix_new_exp (frag_now
,
2216 f
- frag_now
->fr_literal
, 4,
2218 (operand
->flags
& V850_OPERAND_DISP
) != 0,
2219 (bfd_reloc_code_real_type
) (fixups
[i
].opindex
2220 + (int) BFD_RELOC_UNUSED
));
2224 input_line_pointer
= saved_input_line_pointer
;
2227 /* If while processing a fixup, a reloc really needs to be created
2228 then it is done here. */
2231 tc_gen_reloc (seg
, fixp
)
2232 asection
*seg ATTRIBUTE_UNUSED
;
2237 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2238 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2239 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2240 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2242 if ( fixp
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
2243 || fixp
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2244 || fixp
->fx_r_type
== BFD_RELOC_V850_LONGCALL
2245 || fixp
->fx_r_type
== BFD_RELOC_V850_LONGJUMP
2246 || fixp
->fx_r_type
== BFD_RELOC_V850_ALIGN
)
2247 reloc
->addend
= fixp
->fx_offset
;
2250 if (fixp
->fx_r_type
== BFD_RELOC_32
2252 fixp
->fx_r_type
= BFD_RELOC_32_PCREL
;
2254 reloc
->addend
= fixp
->fx_addnumber
;
2257 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
2259 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
2261 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2262 /* xgettext:c-format */
2263 _("reloc %d not supported by object file format"),
2264 (int) fixp
->fx_r_type
);
2275 v850_handle_align (frag
)
2279 && frag
->fr_type
== rs_align
2280 && frag
->fr_address
+ frag
->fr_fix
> 0
2281 && frag
->fr_offset
> 1
2282 && now_seg
!= bss_section
2283 && now_seg
!= v850_seg_table
[SBSS_SECTION
].s
2284 && now_seg
!= v850_seg_table
[TBSS_SECTION
].s
2285 && now_seg
!= v850_seg_table
[ZBSS_SECTION
].s
)
2286 fix_new (frag
, frag
->fr_fix
, 2, & abs_symbol
, frag
->fr_offset
, 0,
2287 BFD_RELOC_V850_ALIGN
);
2290 /* Return current size of variable part of frag. */
2293 md_estimate_size_before_relax (fragp
, seg
)
2295 asection
*seg ATTRIBUTE_UNUSED
;
2297 if (fragp
->fr_subtype
>= sizeof (md_relax_table
) / sizeof (md_relax_table
[0]))
2300 return md_relax_table
[fragp
->fr_subtype
].rlx_length
;
2304 v850_pcrel_from_section (fixp
, section
)
2308 /* If the symbol is undefined, or in a section other than our own,
2309 or it is weak (in which case it may well be in another section,
2310 then let the linker figure it out. */
2311 if (fixp
->fx_addsy
!= (symbolS
*) NULL
2312 && (! S_IS_DEFINED (fixp
->fx_addsy
)
2313 || S_IS_WEAK (fixp
->fx_addsy
)
2314 || (S_GET_SEGMENT (fixp
->fx_addsy
) != section
)))
2317 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2321 md_apply_fix3 (fixP
, valueP
, seg
)
2324 segT seg ATTRIBUTE_UNUSED
;
2326 valueT value
= * valueP
;
2329 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2330 || fixP
->fx_r_type
== BFD_RELOC_V850_LONGCALL
2331 || fixP
->fx_r_type
== BFD_RELOC_V850_LONGJUMP
2332 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2338 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
2339 fixP
->fx_addnumber
= value
,
2342 else if (fixP
->fx_pcrel
)
2343 fixP
->fx_addnumber
= fixP
->fx_offset
;
2347 value
= fixP
->fx_offset
;
2348 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
2350 if (S_GET_SEGMENT (fixP
->fx_subsy
) == absolute_section
)
2351 value
-= S_GET_VALUE (fixP
->fx_subsy
);
2354 /* We don't actually support subtracting a symbol. */
2355 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2356 _("expression too complex"));
2359 fixP
->fx_addnumber
= value
;
2362 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
2365 const struct v850_operand
*operand
;
2368 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
2369 operand
= &v850_operands
[opindex
];
2371 /* Fetch the instruction, insert the fully resolved operand
2372 value, and stuff the instruction back again.
2374 Note the instruction has been stored in little endian
2376 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2378 insn
= bfd_getl32 ((unsigned char *) where
);
2379 insn
= v850_insert_operand (insn
, operand
, (offsetT
) value
,
2380 fixP
->fx_file
, fixP
->fx_line
, NULL
);
2381 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
2384 /* Nothing else to do here. */
2387 /* Determine a BFD reloc value based on the operand information.
2388 We are only prepared to turn a few of the operands into relocs. */
2390 if (operand
->bits
== 22)
2391 fixP
->fx_r_type
= BFD_RELOC_V850_22_PCREL
;
2392 else if (operand
->bits
== 9)
2393 fixP
->fx_r_type
= BFD_RELOC_V850_9_PCREL
;
2397 fprintf (stderr
, "bits: %d, insn: %x\n", operand
->bits
, insn
);
2400 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2401 _("unresolved expression that must be resolved"));
2406 else if (fixP
->fx_done
)
2408 /* We still have to insert the value into memory! */
2409 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2411 if (fixP
->fx_size
== 1)
2412 *where
= value
& 0xff;
2413 else if (fixP
->fx_size
== 2)
2414 bfd_putl16 (value
& 0xffff, (unsigned char *) where
);
2415 else if (fixP
->fx_size
== 4)
2416 bfd_putl32 (value
, (unsigned char *) where
);
2420 /* Parse a cons expression. We have to handle hi(), lo(), etc
2424 parse_cons_expression_v850 (exp
)
2427 /* See if there's a reloc prefix like hi() we have to handle. */
2428 hold_cons_reloc
= v850_reloc_prefix (NULL
);
2430 /* Do normal expression parsing. */
2434 /* Create a fixup for a cons expression. If parse_cons_expression_v850
2435 found a reloc prefix, then we use that reloc, else we choose an
2436 appropriate one based on the size of the expression. */
2439 cons_fix_new_v850 (frag
, where
, size
, exp
)
2445 if (hold_cons_reloc
== BFD_RELOC_UNUSED
)
2448 hold_cons_reloc
= BFD_RELOC_32
;
2450 hold_cons_reloc
= BFD_RELOC_16
;
2452 hold_cons_reloc
= BFD_RELOC_8
;
2456 fix_new_exp (frag
, where
, size
, exp
, 0, hold_cons_reloc
);
2458 fix_new (frag
, where
, size
, NULL
, 0, 0, hold_cons_reloc
);
2460 hold_cons_reloc
= BFD_RELOC_UNUSED
;
2464 v850_fix_adjustable (fixP
)
2467 if (fixP
->fx_addsy
== NULL
)
2470 /* Don't adjust function names. */
2471 if (S_IS_FUNCTION (fixP
->fx_addsy
))
2474 /* We need the symbol name for the VTABLE entries. */
2475 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2476 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2483 v850_force_relocation (fixP
)
2486 if (fixP
->fx_r_type
== BFD_RELOC_V850_LONGCALL
2487 || fixP
->fx_r_type
== BFD_RELOC_V850_LONGJUMP
)
2492 || fixP
->fx_r_type
== BFD_RELOC_V850_ALIGN
2493 || fixP
->fx_r_type
== BFD_RELOC_V850_22_PCREL
2494 || fixP
->fx_r_type
== BFD_RELOC_V850_9_PCREL
2495 || fixP
->fx_r_type
>= BFD_RELOC_UNUSED
))
2498 return generic_force_reloc (fixP
);