1 /* tc-v850.c -- Assembler code for the NEC V850
2 Copyright 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
25 #include "opcode/v850.h"
26 #include "dwarf2dbg.h"
32 /* Sign-extend a 16-bit number. */
33 #define SEXT16(x) ((((x) & 0xffff) ^ (~0x7fff)) + 0x8000)
35 /* Temporarily holds the reloc in a cons expression. */
36 static bfd_reloc_code_real_type hold_cons_reloc = BFD_RELOC_UNUSED;
38 /* Set to TRUE if we want to be pedantic about signed overflows. */
39 static boolean warn_signed_overflows = FALSE;
40 static boolean warn_unsigned_overflows = FALSE;
42 /* Indicates the target BFD machine number. */
43 static int machine = -1;
45 /* Indicates the target processor(s) for the assemble. */
46 static int processor_mask = -1;
48 /* Structure to hold information about predefined registers. */
54 /* Generic assembler global variables which must be defined by all
57 /* Characters which always start a comment. */
58 const char comment_chars[] = "#";
60 /* Characters which start a comment at the beginning of a line. */
61 const char line_comment_chars[] = ";#";
63 /* Characters which may be used to separate multiple commands on a
65 const char line_separator_chars[] = ";";
67 /* Characters which are used to indicate an exponent in a floating
69 const char EXP_CHARS[] = "eE";
71 /* Characters which mean that a number is a floating point constant,
73 const char FLT_CHARS[] = "dD";
75 const relax_typeS md_relax_table[] = {
76 /* Conditional branches. */
78 {0x1fffff, -0x200000, 6, 0},
79 /* Unconditional branches. */
81 {0x1fffff, -0x200000, 4, 0},
84 static segT sdata_section = NULL;
85 static segT tdata_section = NULL;
86 static segT zdata_section = NULL;
87 static segT sbss_section = NULL;
88 static segT tbss_section = NULL;
89 static segT zbss_section = NULL;
90 static segT rosdata_section = NULL;
91 static segT rozdata_section = NULL;
92 static segT scommon_section = NULL;
93 static segT tcommon_section = NULL;
94 static segT zcommon_section = NULL;
95 static segT call_table_data_section = NULL;
96 static segT call_table_text_section = NULL;
99 #define MAX_INSN_FIXUPS (5)
103 bfd_reloc_code_real_type reloc;
106 struct v850_fixup fixups[MAX_INSN_FIXUPS];
110 v850_sdata (int ignore ATTRIBUTE_UNUSED)
112 obj_elf_section_change_hook ();
114 subseg_set (sdata_section, (subsegT) get_absolute_expression ());
116 demand_empty_rest_of_line ();
120 v850_tdata (int ignore ATTRIBUTE_UNUSED)
122 obj_elf_section_change_hook ();
124 subseg_set (tdata_section, (subsegT) get_absolute_expression ());
126 demand_empty_rest_of_line ();
130 v850_zdata (int ignore ATTRIBUTE_UNUSED)
132 obj_elf_section_change_hook ();
134 subseg_set (zdata_section, (subsegT) get_absolute_expression ());
136 demand_empty_rest_of_line ();
140 v850_sbss (int ignore ATTRIBUTE_UNUSED)
142 obj_elf_section_change_hook ();
144 subseg_set (sbss_section, (subsegT) get_absolute_expression ());
146 demand_empty_rest_of_line ();
150 v850_tbss (int ignore ATTRIBUTE_UNUSED)
152 obj_elf_section_change_hook ();
154 subseg_set (tbss_section, (subsegT) get_absolute_expression ());
156 demand_empty_rest_of_line ();
160 v850_zbss (int ignore ATTRIBUTE_UNUSED)
162 obj_elf_section_change_hook ();
164 subseg_set (zbss_section, (subsegT) get_absolute_expression ());
166 demand_empty_rest_of_line ();
170 v850_rosdata (int ignore ATTRIBUTE_UNUSED)
172 obj_elf_section_change_hook ();
174 subseg_set (rosdata_section, (subsegT) get_absolute_expression ());
176 demand_empty_rest_of_line ();
180 v850_rozdata (int ignore ATTRIBUTE_UNUSED)
182 obj_elf_section_change_hook ();
184 subseg_set (rozdata_section, (subsegT) get_absolute_expression ());
186 demand_empty_rest_of_line ();
190 v850_call_table_data (int ignore ATTRIBUTE_UNUSED)
192 obj_elf_section_change_hook ();
194 subseg_set (call_table_data_section, (subsegT) get_absolute_expression ());
196 demand_empty_rest_of_line ();
200 v850_call_table_text (int ignore ATTRIBUTE_UNUSED)
202 obj_elf_section_change_hook ();
204 subseg_set (call_table_text_section, (subsegT) get_absolute_expression ());
206 demand_empty_rest_of_line ();
210 v850_bss (int ignore ATTRIBUTE_UNUSED)
212 register int temp = get_absolute_expression ();
214 obj_elf_section_change_hook ();
216 subseg_set (bss_section, (subsegT) temp);
218 demand_empty_rest_of_line ();
222 v850_offset (int ignore ATTRIBUTE_UNUSED)
224 int temp = get_absolute_expression ();
226 temp -= frag_now_fix ();
229 (void) frag_more (temp);
231 demand_empty_rest_of_line ();
234 /* Copied from obj_elf_common() in gas/config/obj-elf.c. */
248 name = input_line_pointer;
249 c = get_symbol_end ();
251 /* Just after name is now '\0'. */
252 p = input_line_pointer;
257 if (*input_line_pointer != ',')
259 as_bad (_("Expected comma after symbol-name"));
260 ignore_rest_of_line ();
265 input_line_pointer++;
267 if ((temp = get_absolute_expression ()) < 0)
269 /* xgettext:c-format */
270 as_bad (_(".COMMon length (%d.) < 0! Ignored."), temp);
271 ignore_rest_of_line ();
277 symbolP = symbol_find_or_make (name);
280 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
282 as_bad (_("Ignoring attempt to re-define symbol"));
283 ignore_rest_of_line ();
287 if (S_GET_VALUE (symbolP) != 0)
289 if (S_GET_VALUE (symbolP) != size)
291 /* xgettext:c-format */
292 as_warn (_("Length of .comm \"%s\" is already %ld. Not changed to %d."),
293 S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size);
297 know (symbol_get_frag (symbolP) == &zero_address_frag);
299 if (*input_line_pointer != ',')
304 input_line_pointer++;
308 if (! have_align || *input_line_pointer != '"')
314 temp = get_absolute_expression ();
319 as_warn (_("Common alignment negative; 0 assumed"));
323 if (symbol_get_obj (symbolP)->local)
332 old_subsec = now_subseg;
334 applicable = bfd_applicable_section_flags (stdoutput);
336 applicable &= SEC_ALLOC;
341 if (sbss_section == NULL)
343 sbss_section = subseg_new (".sbss", 0);
345 bfd_set_section_flags (stdoutput, sbss_section, applicable);
347 seg_info (sbss_section)->bss = 1;
352 if (zbss_section == NULL)
354 zbss_section = subseg_new (".zbss", 0);
356 bfd_set_section_flags (stdoutput, sbss_section, applicable);
358 seg_info (zbss_section)->bss = 1;
363 if (tbss_section == NULL)
365 tbss_section = subseg_new (".tbss", 0);
367 bfd_set_section_flags (stdoutput, tbss_section, applicable);
369 seg_info (tbss_section)->bss = 1;
376 /* Convert to a power of 2 alignment. */
377 for (align = 0; (temp & 1) == 0; temp >>= 1, ++align)
382 as_bad (_("Common alignment not a power of 2"));
383 ignore_rest_of_line ();
393 record_alignment (sbss_section, align);
394 obj_elf_section_change_hook ();
395 subseg_set (sbss_section, 0);
399 record_alignment (zbss_section, align);
400 obj_elf_section_change_hook ();
401 subseg_set (zbss_section, 0);
405 record_alignment (tbss_section, align);
406 obj_elf_section_change_hook ();
407 subseg_set (tbss_section, 0);
415 frag_align (align, 0, 0);
420 if (S_GET_SEGMENT (symbolP) == sbss_section)
421 symbol_get_frag (symbolP)->fr_symbol = 0;
425 if (S_GET_SEGMENT (symbolP) == zbss_section)
426 symbol_get_frag (symbolP)->fr_symbol = 0;
430 if (S_GET_SEGMENT (symbolP) == tbss_section)
431 symbol_get_frag (symbolP)->fr_symbol = 0;
438 symbol_set_frag (symbolP, frag_now);
439 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
440 (offsetT) size, (char *) 0);
442 S_SET_SIZE (symbolP, size);
447 S_SET_SEGMENT (symbolP, sbss_section);
451 S_SET_SEGMENT (symbolP, zbss_section);
455 S_SET_SEGMENT (symbolP, tbss_section);
462 S_CLEAR_EXTERNAL (symbolP);
463 obj_elf_section_change_hook ();
464 subseg_set (old_sec, old_subsec);
469 S_SET_VALUE (symbolP, (valueT) size);
470 S_SET_ALIGN (symbolP, temp);
471 S_SET_EXTERNAL (symbolP);
476 if (scommon_section == NULL)
478 flagword applicable =
479 bfd_applicable_section_flags (stdoutput);
481 scommon_section = subseg_new (".scommon", 0);
483 bfd_set_section_flags (stdoutput, scommon_section,
485 & (SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA
486 | SEC_HAS_CONTENTS)) | SEC_IS_COMMON);
488 S_SET_SEGMENT (symbolP, scommon_section);
492 if (zcommon_section == NULL)
494 flagword applicable =
495 bfd_applicable_section_flags (stdoutput);
497 zcommon_section = subseg_new (".zcommon", 0);
499 bfd_set_section_flags (stdoutput, zcommon_section,
501 & (SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA
502 | SEC_HAS_CONTENTS)) | SEC_IS_COMMON);
504 S_SET_SEGMENT (symbolP, zcommon_section);
508 if (tcommon_section == NULL)
510 flagword applicable =
511 bfd_applicable_section_flags (stdoutput);
513 tcommon_section = subseg_new (".tcommon", 0);
515 bfd_set_section_flags (stdoutput, tcommon_section,
517 & (SEC_ALLOC | SEC_LOAD
518 | SEC_RELOC | SEC_DATA
522 S_SET_SEGMENT (symbolP, tcommon_section);
532 input_line_pointer++;
534 /* @@ Some use the dot, some don't. Can we get some consistency?? */
535 if (*input_line_pointer == '.')
536 input_line_pointer++;
538 /* @@ Some say data, some say bss. */
539 if (strncmp (input_line_pointer, "bss\"", 4)
540 && strncmp (input_line_pointer, "data\"", 5))
542 while (*--input_line_pointer != '"')
544 input_line_pointer--;
545 goto bad_common_segment;
547 while (*input_line_pointer++ != '"')
549 goto allocate_common;
552 symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
554 demand_empty_rest_of_line ();
559 p = input_line_pointer;
560 while (*p && *p != '\n')
564 as_bad (_("bad .common segment %s"), input_line_pointer + 1);
566 input_line_pointer = p;
567 ignore_rest_of_line ();
573 set_machine (int number)
576 bfd_set_arch_mach (stdoutput, TARGET_ARCH, machine);
580 case 0: processor_mask = PROCESSOR_V850; break;
581 case bfd_mach_v850e: processor_mask = PROCESSOR_V850E; break;
582 case bfd_mach_v850ea: processor_mask = PROCESSOR_V850EA; break;
586 /* The target specific pseudo-ops which we support. */
587 const pseudo_typeS md_pseudo_table[] = {
588 {"sdata", v850_sdata, 0},
589 {"tdata", v850_tdata, 0},
590 {"zdata", v850_zdata, 0},
591 {"sbss", v850_sbss, 0},
592 {"tbss", v850_tbss, 0},
593 {"zbss", v850_zbss, 0},
594 {"rosdata", v850_rosdata, 0},
595 {"rozdata", v850_rozdata, 0},
596 {"bss", v850_bss, 0},
597 {"offset", v850_offset, 0},
599 {"zcomm", v850_comm, AREA_ZDA},
600 {"scomm", v850_comm, AREA_SDA},
601 {"tcomm", v850_comm, AREA_TDA},
602 {"v850", set_machine, 0},
603 {"call_table_data", v850_call_table_data, 0},
604 {"call_table_text", v850_call_table_text, 0},
605 {"v850e", set_machine, bfd_mach_v850e},
606 {"v850ea", set_machine, bfd_mach_v850ea},
607 {"file", dwarf2_directive_file, 0},
608 {"loc", dwarf2_directive_loc, 0},
612 /* Opcode hash table. */
613 static struct hash_control *v850_hash;
615 /* This table is sorted. Suitable for searching by a binary search. */
616 static const struct reg_name pre_defined_registers[] = {
617 { "ep", 30 }, /* ep - element ptr */
618 { "gp", 4 }, /* gp - global ptr */
619 { "hp", 2 }, /* hp - handler stack ptr */
620 { "lp", 31 }, /* lp - link ptr */
653 { "sp", 3 }, /* sp - stack ptr */
654 { "tp", 5 }, /* tp - text ptr */
658 #define REG_NAME_CNT \
659 (sizeof (pre_defined_registers) / sizeof (struct reg_name))
661 static const struct reg_name system_registers[] = {
675 #define SYSREG_NAME_CNT \
676 (sizeof (system_registers) / sizeof (struct reg_name))
678 static const struct reg_name system_list_registers[] = {
683 #define SYSREGLIST_NAME_CNT \
684 (sizeof (system_list_registers) / sizeof (struct reg_name))
686 static const struct reg_name cc_names[] = {
711 #define CC_NAME_CNT \
712 (sizeof (cc_names) / sizeof (struct reg_name))
714 /* Do a binary search of the given register table to see if NAME is a
715 valid regiter name. Return the register number from the array on
716 success, or -1 on failure. */
719 reg_name_search (regs, regcount, name, accept_numbers)
720 const struct reg_name *regs;
723 boolean accept_numbers;
725 int middle, low, high;
729 /* If the register name is a symbol, then evaluate it. */
730 if ((symbolP = symbol_find (name)) != NULL)
732 /* If the symbol is an alias for another name then use that.
733 If the symbol is an alias for a number, then return the number. */
734 if (symbol_equated_p (symbolP))
737 = S_GET_NAME (symbol_get_value_expression (symbolP)->X_add_symbol);
739 else if (accept_numbers)
741 int reg = S_GET_VALUE (symbolP);
743 if (reg >= 0 && reg <= 31)
747 /* Otherwise drop through and try parsing name normally. */
755 middle = (low + high) / 2;
756 cmp = strcasecmp (name, regs[middle].name);
762 return regs[middle].value;
768 /* Summary of register_name().
770 * in: Input_line_pointer points to 1st char of operand.
772 * out: A expressionS.
773 * The operand may have been a register: in this case, X_op == O_register,
774 * X_add_number is set to the register number, and truth is returned.
775 * Input_line_pointer->(next non-blank) char after operand, or is in
776 * its original state. */
779 register_name (expressionP)
780 expressionS *expressionP;
787 /* Find the spelling of the operand. */
788 start = name = input_line_pointer;
790 c = get_symbol_end ();
792 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT,
795 /* Put back the delimiting char. */
796 *input_line_pointer = c;
798 /* Look to see if it's in the register table. */
801 expressionP->X_op = O_register;
802 expressionP->X_add_number = reg_number;
804 /* Make the rest nice. */
805 expressionP->X_add_symbol = NULL;
806 expressionP->X_op_symbol = NULL;
812 /* Reset the line as if we had not done anything. */
813 input_line_pointer = start;
819 /* Summary of system_register_name().
821 * in: INPUT_LINE_POINTER points to 1st char of operand.
822 * EXPRESSIONP points to an expression structure to be filled in.
823 * ACCEPT_NUMBERS is true iff numerical register names may be used.
824 * ACCEPT_LIST_NAMES is true iff the special names PS and SR may be
827 * out: A expressionS structure in expressionP.
828 * The operand may have been a register: in this case, X_op == O_register,
829 * X_add_number is set to the register number, and truth is returned.
830 * Input_line_pointer->(next non-blank) char after operand, or is in
831 * its original state. */
834 system_register_name (expressionP, accept_numbers, accept_list_names)
835 expressionS *expressionP;
836 boolean accept_numbers;
837 boolean accept_list_names;
844 /* Find the spelling of the operand. */
845 start = name = input_line_pointer;
847 c = get_symbol_end ();
848 reg_number = reg_name_search (system_registers, SYSREG_NAME_CNT, name,
851 /* Put back the delimiting char. */
852 *input_line_pointer = c;
857 /* Reset input_line pointer. */
858 input_line_pointer = start;
860 if (isdigit (*input_line_pointer))
862 reg_number = strtol (input_line_pointer, &input_line_pointer, 10);
864 /* Make sure that the register number is allowable. */
866 || (reg_number > 5 && reg_number < 16)
872 else if (accept_list_names)
874 c = get_symbol_end ();
875 reg_number = reg_name_search (system_list_registers,
876 SYSREGLIST_NAME_CNT, name, FALSE);
878 /* Put back the delimiting char. */
879 *input_line_pointer = c;
883 /* Look to see if it's in the register table. */
886 expressionP->X_op = O_register;
887 expressionP->X_add_number = reg_number;
889 /* Make the rest nice. */
890 expressionP->X_add_symbol = NULL;
891 expressionP->X_op_symbol = NULL;
897 /* Reset the line as if we had not done anything. */
898 input_line_pointer = start;
904 /* Summary of cc_name().
906 * in: INPUT_LINE_POINTER points to 1st char of operand.
908 * out: A expressionS.
909 * The operand may have been a register: in this case, X_op == O_register,
910 * X_add_number is set to the register number, and truth is returned.
911 * Input_line_pointer->(next non-blank) char after operand, or is in
912 * its original state. */
915 cc_name (expressionP)
916 expressionS *expressionP;
923 /* Find the spelling of the operand. */
924 start = name = input_line_pointer;
926 c = get_symbol_end ();
927 reg_number = reg_name_search (cc_names, CC_NAME_CNT, name, FALSE);
929 /* Put back the delimiting char. */
930 *input_line_pointer = c;
932 /* Look to see if it's in the register table. */
935 expressionP->X_op = O_constant;
936 expressionP->X_add_number = reg_number;
938 /* Make the rest nice. */
939 expressionP->X_add_symbol = NULL;
940 expressionP->X_op_symbol = NULL;
946 /* Reset the line as if we had not done anything. */
947 input_line_pointer = start;
954 skip_white_space (void)
956 while (*input_line_pointer == ' '
957 || *input_line_pointer == '\t')
958 ++input_line_pointer;
961 /* Summary of parse_register_list ().
963 * in: INPUT_LINE_POINTER points to 1st char of a list of registers.
964 * INSN is the partially constructed instruction.
965 * OPERAND is the operand being inserted.
967 * out: NULL if the parse completed successfully, otherwise a
968 * pointer to an error message is returned. If the parse
969 * completes the correct bit fields in the instruction
972 * Parses register lists with the syntax:
980 * and also parses constant epxressions whoes bits indicate the
981 * registers in the lists. The LSB in the expression refers to
982 * the lowest numbered permissable register in the register list,
983 * and so on upwards. System registers are considered to be very
987 parse_register_list (insn, operand)
989 const struct v850_operand *operand;
991 static int type1_regs[32] = {
992 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
993 0, 0, 0, 0, 0, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
995 static int type2_regs[32] = {
996 19, 18, 17, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
997 0, 0, 0, 0, 30, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
999 static int type3_regs[32] = {
1000 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1001 0, 0, 0, 0, 14, 15, 13, 12, 7, 6, 5, 4, 11, 10, 9, 8
1006 /* Select a register array to parse. */
1007 switch (operand->shift)
1009 case 0xffe00001: regs = type1_regs; break;
1010 case 0xfff8000f: regs = type2_regs; break;
1011 case 0xfff8001f: regs = type3_regs; break;
1013 as_bad (_("unknown operand shift: %x\n"), operand->shift);
1014 return _("internal failure in parse_register_list");
1017 skip_white_space ();
1019 /* If the expression starts with a curly brace it is a register list.
1020 Otherwise it is a constant expression, whoes bits indicate which
1021 registers are to be included in the list. */
1023 if (*input_line_pointer != '{')
1030 if (exp.X_op != O_constant)
1031 return _("constant expression or register list expected");
1033 if (regs == type1_regs)
1035 if (exp.X_add_number & 0xFFFFF000)
1036 return _("high bits set in register list expression");
1038 for (reg = 20; reg < 32; reg++)
1039 if (exp.X_add_number & (1 << (reg - 20)))
1041 for (i = 0; i < 32; i++)
1046 else if (regs == type2_regs)
1048 if (exp.X_add_number & 0xFFFE0000)
1049 return _("high bits set in register list expression");
1051 for (reg = 1; reg < 16; reg++)
1052 if (exp.X_add_number & (1 << (reg - 1)))
1054 for (i = 0; i < 32; i++)
1059 if (exp.X_add_number & (1 << 15))
1062 if (exp.X_add_number & (1 << 16))
1065 else /* regs == type3_regs */
1067 if (exp.X_add_number & 0xFFFE0000)
1068 return _("high bits set in register list expression");
1070 for (reg = 16; reg < 32; reg++)
1071 if (exp.X_add_number & (1 << (reg - 16)))
1073 for (i = 0; i < 32; i++)
1078 if (exp.X_add_number & (1 << 16))
1085 input_line_pointer++;
1087 /* Parse the register list until a terminator (closing curly brace or
1088 new-line) is found. */
1091 if (register_name (&exp))
1095 /* Locate the given register in the list, and if it is there,
1096 insert the corresponding bit into the instruction. */
1097 for (i = 0; i < 32; i++)
1099 if (regs[i] == exp.X_add_number)
1108 return _("illegal register included in list");
1111 else if (system_register_name (&exp, true, true))
1113 if (regs == type1_regs)
1115 return _("system registers cannot be included in list");
1117 else if (exp.X_add_number == 5)
1119 if (regs == type2_regs)
1120 return _("PSW cannot be included in list");
1124 else if (exp.X_add_number < 4)
1127 return _("High value system registers cannot be included in list");
1129 else if (*input_line_pointer == '}')
1131 input_line_pointer++;
1134 else if (*input_line_pointer == ',')
1136 input_line_pointer++;
1139 else if (*input_line_pointer == '-')
1141 /* We have encountered a range of registers: rX - rY. */
1145 /* Skip the dash. */
1146 ++input_line_pointer;
1148 /* Get the second register in the range. */
1149 if (! register_name (&exp2))
1151 return _("second register should follow dash in register list");
1152 exp2.X_add_number = exp.X_add_number;
1155 /* Add the rest of the registers in the range. */
1156 for (j = exp.X_add_number + 1; j <= exp2.X_add_number; j++)
1160 /* Locate the given register in the list, and if it is there,
1161 insert the corresponding bit into the instruction. */
1162 for (i = 0; i < 32; i++)
1172 return _("illegal register included in list");
1180 skip_white_space ();
1186 CONST char *md_shortopts = "m:";
1188 struct option md_longopts[] = {
1189 {NULL, no_argument, NULL, 0}
1192 size_t md_longopts_size = sizeof (md_longopts);
1195 md_show_usage (stream)
1198 fprintf (stream, _(" V850 options:\n"));
1199 fprintf (stream, _(" -mwarn-signed-overflow Warn if signed immediate values overflow\n"));
1200 fprintf (stream, _(" -mwarn-unsigned-overflow Warn if unsigned immediate values overflow\n"));
1201 fprintf (stream, _(" -mv850 The code is targeted at the v850\n"));
1202 fprintf (stream, _(" -mv850e The code is targeted at the v850e\n"));
1203 fprintf (stream, _(" -mv850ea The code is targeted at the v850ea\n"));
1204 fprintf (stream, _(" -mv850any The code is generic, despite any processor specific instructions\n"));
1208 md_parse_option (c, arg)
1215 /* xgettext:c-format */
1216 fprintf (stderr, _("unknown command line option: -%c%s\n"), c, arg);
1220 if (strcmp (arg, "warn-signed-overflow") == 0)
1222 warn_signed_overflows = TRUE;
1224 else if (strcmp (arg, "warn-unsigned-overflow") == 0)
1226 warn_unsigned_overflows = TRUE;
1228 else if (strcmp (arg, "v850") == 0)
1231 processor_mask = PROCESSOR_V850;
1233 else if (strcmp (arg, "v850e") == 0)
1235 machine = bfd_mach_v850e;
1236 processor_mask = PROCESSOR_V850E;
1238 else if (strcmp (arg, "v850ea") == 0)
1240 machine = bfd_mach_v850ea;
1241 processor_mask = PROCESSOR_V850EA;
1243 else if (strcmp (arg, "v850any") == 0)
1245 /* Tell the world that this is for any v850 chip. */
1248 /* But support instructions for the extended versions. */
1249 processor_mask = PROCESSOR_V850EA;
1253 /* xgettext:c-format */
1254 fprintf (stderr, _("unknown command line option: -%c%s\n"), c, arg);
1262 md_undefined_symbol (name)
1263 char *name ATTRIBUTE_UNUSED;
1269 md_atof (type, litp, sizep)
1275 LITTLENUM_TYPE words[4];
1291 return _("bad call to md_atof");
1294 t = atof_ieee (input_line_pointer, type, words);
1296 input_line_pointer = t;
1300 for (i = prec - 1; i >= 0; i--)
1302 md_number_to_chars (litp, (valueT) words[i], 2);
1312 md_convert_frag (abfd, sec, fragP)
1313 bfd *abfd ATTRIBUTE_UNUSED;
1317 subseg_change (sec, 0);
1319 /* In range conditional or unconditional branch. */
1320 if (fragP->fr_subtype == 0 || fragP->fr_subtype == 2)
1322 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
1323 fragP->fr_offset, 1, BFD_RELOC_UNUSED + (int)fragP->fr_opcode);
1326 /* Out of range conditional branch. Emit a branch around a jump. */
1327 else if (fragP->fr_subtype == 1)
1329 unsigned char *buffer =
1330 (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1332 /* Reverse the condition of the first branch. */
1334 /* Mask off all the displacement bits. */
1337 /* Now set the displacement bits so that we branch
1338 around the unconditional branch. */
1341 /* Now create the unconditional branch + fixup to the final
1343 md_number_to_chars (buffer + 2, 0x00000780, 4);
1344 fix_new (fragP, fragP->fr_fix + 2, 4, fragP->fr_symbol,
1345 fragP->fr_offset, 1, BFD_RELOC_UNUSED +
1346 (int) fragP->fr_opcode + 1);
1349 /* Out of range unconditional branch. Emit a jump. */
1350 else if (fragP->fr_subtype == 3)
1352 md_number_to_chars (fragP->fr_fix + fragP->fr_literal, 0x00000780, 4);
1353 fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
1354 fragP->fr_offset, 1, BFD_RELOC_UNUSED +
1355 (int) fragP->fr_opcode + 1);
1363 md_section_align (seg, addr)
1367 int align = bfd_get_section_alignment (stdoutput, seg);
1368 return ((addr + (1 << align) - 1) & (-1 << align));
1374 char *prev_name = "";
1375 register const struct v850_opcode *op;
1376 flagword applicable;
1378 if (strncmp (TARGET_CPU, "v850ea", 6) == 0)
1381 machine = bfd_mach_v850ea;
1383 if (processor_mask == -1)
1384 processor_mask = PROCESSOR_V850EA;
1386 else if (strncmp (TARGET_CPU, "v850e", 5) == 0)
1389 machine = bfd_mach_v850e;
1391 if (processor_mask == -1)
1392 processor_mask = PROCESSOR_V850E;
1394 else if (strncmp (TARGET_CPU, "v850", 4) == 0)
1399 if (processor_mask == -1)
1400 processor_mask = PROCESSOR_V850;
1403 /* xgettext:c-format */
1404 as_bad (_("Unable to determine default target processor from string: %s"),
1407 v850_hash = hash_new ();
1409 /* Insert unique names into hash table. The V850 instruction set
1410 has many identical opcode names that have different opcodes based
1411 on the operands. This hash table then provides a quick index to
1412 the first opcode with a particular name in the opcode table. */
1417 if (strcmp (prev_name, op->name))
1419 prev_name = (char *) op->name;
1420 hash_insert (v850_hash, op->name, (char *) op);
1425 bfd_set_arch_mach (stdoutput, TARGET_ARCH, machine);
1427 applicable = bfd_applicable_section_flags (stdoutput);
1429 call_table_data_section = subseg_new (".call_table_data", 0);
1430 bfd_set_section_flags (stdoutput, call_table_data_section,
1431 applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1432 | SEC_DATA | SEC_HAS_CONTENTS));
1434 call_table_text_section = subseg_new (".call_table_text", 0);
1435 bfd_set_section_flags (stdoutput, call_table_text_section,
1436 applicable & (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1439 /* Restore text section as the current default. */
1440 subseg_set (text_section, 0);
1443 static bfd_reloc_code_real_type
1444 handle_ctoff (const struct v850_operand *operand)
1446 if (operand == NULL)
1447 return BFD_RELOC_V850_CALLT_16_16_OFFSET;
1449 if (operand->bits != 6
1450 || operand->shift != 0)
1452 as_bad (_("ctoff() relocation used on an instruction which does not support it"));
1453 return BFD_RELOC_64; /* Used to indicate an error condition. */
1456 return BFD_RELOC_V850_CALLT_6_7_OFFSET;
1459 static bfd_reloc_code_real_type
1460 handle_sdaoff (const struct v850_operand *operand)
1462 if (operand == NULL)
1463 return BFD_RELOC_V850_SDA_16_16_OFFSET;
1465 if (operand->bits == 15 && operand->shift == 17)
1466 return BFD_RELOC_V850_SDA_15_16_OFFSET;
1468 if (operand->bits == -1)
1469 return BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET;
1471 if (operand->bits != 16
1472 || operand->shift != 16)
1474 as_bad (_("sdaoff() relocation used on an instruction which does not support it"));
1475 return BFD_RELOC_64; /* Used to indicate an error condition. */
1478 return BFD_RELOC_V850_SDA_16_16_OFFSET;
1481 static bfd_reloc_code_real_type
1482 handle_zdaoff (const struct v850_operand *operand)
1484 if (operand == NULL)
1485 return BFD_RELOC_V850_ZDA_16_16_OFFSET;
1487 if (operand->bits == 15 && operand->shift == 17)
1488 return BFD_RELOC_V850_ZDA_15_16_OFFSET;
1490 if (operand->bits == -1)
1491 return BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET;
1493 if (operand->bits != 16
1494 || operand->shift != 16)
1496 as_bad (_("zdaoff() relocation used on an instruction which does not support it"));
1497 /* Used to indicate an error condition. */
1498 return BFD_RELOC_64;
1501 return BFD_RELOC_V850_ZDA_16_16_OFFSET;
1504 static bfd_reloc_code_real_type
1505 handle_tdaoff (const struct v850_operand *operand)
1507 if (operand == NULL)
1508 /* Data item, not an instruction. */
1509 return BFD_RELOC_V850_TDA_7_7_OFFSET;
1511 if (operand->bits == 6 && operand->shift == 1)
1512 /* sld.w/sst.w, operand: D8_6 */
1513 return BFD_RELOC_V850_TDA_6_8_OFFSET;
1515 if (operand->bits == 4 && operand->insert != NULL)
1516 /* sld.hu, operand: D5-4 */
1517 return BFD_RELOC_V850_TDA_4_5_OFFSET;
1519 if (operand->bits == 4 && operand->insert == NULL)
1520 /* sld.bu, operand: D4 */
1521 return BFD_RELOC_V850_TDA_4_4_OFFSET;
1523 if (operand->bits == 16 && operand->shift == 16)
1524 /* set1 & chums, operands: D16 */
1525 return BFD_RELOC_V850_TDA_16_16_OFFSET;
1527 if (operand->bits != 7)
1529 as_bad (_("tdaoff() relocation used on an instruction which does not support it"));
1530 /* Used to indicate an error condition. */
1531 return BFD_RELOC_64;
1534 return operand->insert != NULL
1535 ? BFD_RELOC_V850_TDA_7_8_OFFSET /* sld.h/sst.h, operand: D8_7 */
1536 : BFD_RELOC_V850_TDA_7_7_OFFSET; /* sld.b/sst.b, opreand: D7 */
1539 /* Warning: The code in this function relies upon the definitions
1540 in the v850_operands[] array (defined in opcodes/v850-opc.c)
1541 matching the hard coded values contained herein. */
1543 static bfd_reloc_code_real_type
1544 v850_reloc_prefix (const struct v850_operand *operand)
1546 boolean paren_skipped = false;
1548 /* Skip leading opening parenthesis. */
1549 if (*input_line_pointer == '(')
1551 ++input_line_pointer;
1552 paren_skipped = true;
1555 #define CHECK_(name, reloc) \
1556 if (strncmp (input_line_pointer, name##"(", strlen (name) + 1) == 0) \
1558 input_line_pointer += strlen (name); \
1562 CHECK_ ("hi0", BFD_RELOC_HI16 );
1563 CHECK_ ("hi", BFD_RELOC_HI16_S );
1564 CHECK_ ("lo", BFD_RELOC_LO16 );
1565 CHECK_ ("sdaoff", handle_sdaoff (operand));
1566 CHECK_ ("zdaoff", handle_zdaoff (operand));
1567 CHECK_ ("tdaoff", handle_tdaoff (operand));
1568 CHECK_ ("hilo", BFD_RELOC_32 );
1569 CHECK_ ("ctoff", handle_ctoff (operand) );
1571 /* Restore skipped parenthesis. */
1573 --input_line_pointer;
1575 return BFD_RELOC_UNUSED;
1578 /* Insert an operand value into an instruction. */
1580 static unsigned long
1581 v850_insert_operand (insn, operand, val, file, line, str)
1583 const struct v850_operand *operand;
1589 if (operand->insert)
1591 const char *message = NULL;
1593 insn = operand->insert (insn, val, &message);
1594 if (message != NULL)
1596 if ((operand->flags & V850_OPERAND_SIGNED)
1597 && ! warn_signed_overflows
1598 && strstr (message, "out of range") != NULL)
1600 /* Skip warning... */
1602 else if ((operand->flags & V850_OPERAND_SIGNED) == 0
1603 && ! warn_unsigned_overflows
1604 && strstr (message, "out of range") != NULL)
1606 /* Skip warning... */
1610 if (file == (char *) NULL)
1611 as_warn ("%s: %s", str, message);
1613 as_warn_where (file, line, "%s: %s", str, message);
1617 if (file == (char *) NULL)
1620 as_warn_where (file, line, message);
1626 if (operand->bits != 32)
1630 if ((operand->flags & V850_OPERAND_SIGNED) != 0)
1632 if (! warn_signed_overflows)
1633 max = (1 << operand->bits) - 1;
1635 max = (1 << (operand->bits - 1)) - 1;
1637 min = -(1 << (operand->bits - 1));
1641 max = (1 << operand->bits) - 1;
1643 if (! warn_unsigned_overflows)
1644 min = -(1 << (operand->bits - 1));
1649 if (val < (offsetT) min || val > (offsetT) max)
1651 /* xgettext:c-format */
1653 _("operand out of range (%s not between %ld and %ld)");
1656 /* Restore min and mix to expected values for decimal ranges. */
1657 if ((operand->flags & V850_OPERAND_SIGNED)
1658 && ! warn_signed_overflows)
1659 max = (1 << (operand->bits - 1)) - 1;
1661 if (! (operand->flags & V850_OPERAND_SIGNED)
1662 && ! warn_unsigned_overflows)
1667 sprintf (buf, "%s: ", str);
1669 sprint_value (buf + strlen (buf), val);
1672 sprint_value (buf, val);
1674 if (file == (char *) NULL)
1675 as_warn (err, buf, min, max);
1677 as_warn_where (file, line, err, buf, min, max);
1681 insn |= (((long) val & ((1 << operand->bits) - 1)) << operand->shift);
1687 static char copy_of_instruction[128];
1694 char *start_of_operands;
1695 struct v850_opcode *opcode;
1696 struct v850_opcode *next_opcode;
1697 const unsigned char *opindex_ptr;
1701 unsigned long insn_size;
1702 unsigned long total_insn_size = 0;
1706 boolean extra_data_after_insn = false;
1707 unsigned extra_data_len = 0;
1708 unsigned long extra_data = 0;
1709 char *saved_input_line_pointer;
1711 strncpy (copy_of_instruction, str, sizeof (copy_of_instruction) - 1);
1713 /* Get the opcode. */
1714 for (s = str; *s != '\0' && ! isspace (*s); s++)
1720 /* Find the first opcode with the proper name. */
1721 opcode = (struct v850_opcode *) hash_find (v850_hash, str);
1724 /* xgettext:c-format */
1725 as_bad (_("Unrecognized opcode: `%s'"), str);
1726 ignore_rest_of_line ();
1731 while (isspace (*str))
1734 start_of_operands = str;
1736 saved_input_line_pointer = input_line_pointer;
1740 const char *errmsg = NULL;
1744 if ((opcode->processors & processor_mask) == 0)
1746 errmsg = _("Target processor does not support this instruction.");
1753 insn = opcode->opcode;
1754 extra_data_after_insn = false;
1756 input_line_pointer = str = start_of_operands;
1758 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1760 const struct v850_operand *operand;
1763 bfd_reloc_code_real_type reloc;
1765 if (next_opindex == 0)
1767 operand = &v850_operands[*opindex_ptr];
1771 operand = &v850_operands[next_opindex];
1777 while (*str == ' ' || *str == ',' || *str == '[' || *str == ']')
1780 if (operand->flags & V850_OPERAND_RELAX)
1783 /* Gather the operand. */
1784 hold = input_line_pointer;
1785 input_line_pointer = str;
1787 /* lo(), hi(), hi0(), etc... */
1788 if ((reloc = v850_reloc_prefix (operand)) != BFD_RELOC_UNUSED)
1790 /* This is a fake reloc, used to indicate an error condition. */
1791 if (reloc == BFD_RELOC_64)
1799 if (ex.X_op == O_constant)
1803 case BFD_RELOC_V850_ZDA_16_16_OFFSET:
1804 /* To cope with "not1 7, zdaoff(0xfffff006)[r0]"
1808 case BFD_RELOC_LO16:
1810 /* Truncate, then sign extend the value. */
1811 ex.X_add_number = SEXT16 (ex.X_add_number);
1815 case BFD_RELOC_HI16:
1817 /* Truncate, then sign extend the value. */
1818 ex.X_add_number = SEXT16 (ex.X_add_number >> 16);
1822 case BFD_RELOC_HI16_S:
1824 /* Truncate, then sign extend the value. */
1825 int temp = (ex.X_add_number >> 16) & 0xffff;
1827 temp += (ex.X_add_number >> 15) & 1;
1829 ex.X_add_number = SEXT16 (temp);
1834 if ((operand->flags & V850E_IMMEDIATE32) == 0)
1836 errmsg = _("immediate operand is too large");
1840 extra_data_after_insn = true;
1842 extra_data = ex.X_add_number;
1843 ex.X_add_number = 0;
1847 fprintf (stderr, "reloc: %d\n", reloc);
1848 as_bad (_("AAARG -> unhandled constant reloc"));
1852 if (fc > MAX_INSN_FIXUPS)
1853 as_fatal (_("too many fixups"));
1855 fixups[fc].exp = ex;
1856 fixups[fc].opindex = *opindex_ptr;
1857 fixups[fc].reloc = reloc;
1862 if (reloc == BFD_RELOC_32)
1864 if ((operand->flags & V850E_IMMEDIATE32) == 0)
1866 errmsg = _("immediate operand is too large");
1870 extra_data_after_insn = true;
1872 extra_data = ex.X_add_number;
1875 if (fc > MAX_INSN_FIXUPS)
1876 as_fatal (_("too many fixups"));
1878 fixups[fc].exp = ex;
1879 fixups[fc].opindex = *opindex_ptr;
1880 fixups[fc].reloc = reloc;
1888 if ((operand->flags & V850_OPERAND_REG) != 0)
1890 if (!register_name (&ex))
1892 errmsg = _("invalid register name");
1894 else if ((operand->flags & V850_NOT_R0)
1895 && ex.X_add_number == 0)
1897 errmsg = _("register r0 cannot be used here");
1899 /* Force an error message to be generated by
1900 skipping over any following potential matches
1905 else if ((operand->flags & V850_OPERAND_SRG) != 0)
1907 if (!system_register_name (&ex, true, false))
1909 errmsg = _("invalid system register name");
1912 else if ((operand->flags & V850_OPERAND_EP) != 0)
1914 char *start = input_line_pointer;
1915 char c = get_symbol_end ();
1917 if (strcmp (start, "ep") != 0 && strcmp (start, "r30") != 0)
1919 /* Put things back the way we found them. */
1920 *input_line_pointer = c;
1921 input_line_pointer = start;
1922 errmsg = _("expected EP register");
1926 *input_line_pointer = c;
1927 str = input_line_pointer;
1928 input_line_pointer = hold;
1930 while (*str == ' ' || *str == ','
1931 || *str == '[' || *str == ']')
1935 else if ((operand->flags & V850_OPERAND_CC) != 0)
1939 errmsg = _("invalid condition code name");
1942 else if (operand->flags & V850E_PUSH_POP)
1944 errmsg = parse_register_list (&insn, operand);
1946 /* The parse_register_list() function has already done
1947 everything, so fake a dummy expression. */
1948 ex.X_op = O_constant;
1949 ex.X_add_number = 0;
1951 else if (operand->flags & V850E_IMMEDIATE16)
1955 if (ex.X_op != O_constant)
1956 errmsg = _("constant expression expected");
1957 else if (ex.X_add_number & 0xffff0000)
1959 if (ex.X_add_number & 0xffff)
1960 errmsg = _("constant too big to fit into instruction");
1961 else if ((insn & 0x001fffc0) == 0x00130780)
1962 ex.X_add_number >>= 16;
1964 errmsg = _("constant too big to fit into instruction");
1967 extra_data_after_insn = true;
1969 extra_data = ex.X_add_number;
1970 ex.X_add_number = 0;
1972 else if (operand->flags & V850E_IMMEDIATE32)
1976 if (ex.X_op != O_constant)
1977 errmsg = _("constant expression expected");
1979 extra_data_after_insn = true;
1981 extra_data = ex.X_add_number;
1982 ex.X_add_number = 0;
1984 else if (register_name (&ex)
1985 && (operand->flags & V850_OPERAND_REG) == 0)
1990 /* It is possible that an alias has been defined that
1991 matches a register name. For example the code may
1992 include a ".set ZERO, 0" directive, which matches
1993 the register name "zero". Attempt to reparse the
1994 field as an expression, and only complain if we
1995 cannot generate a constant. */
1997 input_line_pointer = str;
1999 c = get_symbol_end ();
2001 if (symbol_find (str) != NULL)
2004 *input_line_pointer = c;
2005 input_line_pointer = str;
2009 if (ex.X_op != O_constant)
2011 /* If this register is actually occuring too early on
2012 the parsing of the instruction, (because another
2013 field is missing) then report this. */
2014 if (opindex_ptr[1] != 0
2015 && (v850_operands[opindex_ptr[1]].flags
2016 & V850_OPERAND_REG))
2017 errmsg = _("syntax error: value is missing before the register name");
2019 errmsg = _("syntax error: register not expected");
2021 /* If we created a symbol in the process of this
2022 test then delete it now, so that it will not
2023 be output with the real symbols... */
2025 && ex.X_op == O_symbol)
2026 symbol_remove (ex.X_add_symbol,
2027 &symbol_rootP, &symbol_lastP);
2030 else if (system_register_name (&ex, false, false)
2031 && (operand->flags & V850_OPERAND_SRG) == 0)
2033 errmsg = _("syntax error: system register not expected");
2035 else if (cc_name (&ex)
2036 && (operand->flags & V850_OPERAND_CC) == 0)
2038 errmsg = _("syntax error: condition code not expected");
2044 If we are assembling a MOV instruction (or a CALLT.... :-)
2045 and the immediate value does not fit into the bits
2046 available then create a fake error so that the next MOV
2047 instruction will be selected. This one has a 32 bit
2050 if (((insn & 0x07e0) == 0x0200)
2051 && ex.X_op == O_constant
2052 && (ex.X_add_number < (-(1 << (operand->bits - 1)))
2053 || ex.X_add_number > ((1 << operand->bits) - 1)))
2054 errmsg = _("immediate operand is too large");
2062 " insn: %x, operand %d, op: %d, add_number: %d\n",
2063 insn, opindex_ptr - opcode->operands,
2064 ex.X_op, ex.X_add_number);
2070 errmsg = _("illegal operand");
2073 errmsg = _("missing operand");
2077 & (V850_OPERAND_REG | V850_OPERAND_SRG)) == 0)
2079 errmsg = _("invalid operand");
2082 insn = v850_insert_operand (insn, operand, ex.X_add_number,
2084 copy_of_instruction);
2088 insn = v850_insert_operand (insn, operand, ex.X_add_number,
2090 copy_of_instruction);
2094 /* We need to generate a fixup for this expression. */
2095 if (fc >= MAX_INSN_FIXUPS)
2096 as_fatal (_("too many fixups"));
2098 fixups[fc].exp = ex;
2099 fixups[fc].opindex = *opindex_ptr;
2100 fixups[fc].reloc = BFD_RELOC_UNUSED;
2106 str = input_line_pointer;
2107 input_line_pointer = hold;
2109 while (*str == ' ' || *str == ',' || *str == '[' || *str == ']'
2118 next_opcode = opcode + 1;
2119 if (next_opcode->name != NULL
2120 && strcmp (next_opcode->name, opcode->name) == 0)
2122 opcode = next_opcode;
2124 /* Skip versions that are not supported by the target
2126 if ((opcode->processors & processor_mask) == 0)
2132 as_bad ("%s: %s", copy_of_instruction, errmsg);
2134 if (*input_line_pointer == ']')
2135 ++input_line_pointer;
2137 ignore_rest_of_line ();
2138 input_line_pointer = saved_input_line_pointer;
2144 while (isspace (*str))
2148 /* xgettext:c-format */
2149 as_bad (_("junk at end of line: `%s'"), str);
2151 input_line_pointer = str;
2153 /* Write out the instruction. */
2155 if (relaxable && fc > 0)
2160 if (!strcmp (opcode->name, "br"))
2162 f = frag_var (rs_machine_dependent, 4, 2, 2,
2163 fixups[0].exp.X_add_symbol,
2164 fixups[0].exp.X_add_number,
2165 (char *) fixups[0].opindex);
2166 md_number_to_chars (f, insn, insn_size);
2167 md_number_to_chars (f + 2, 0, 2);
2171 f = frag_var (rs_machine_dependent, 6, 4, 0,
2172 fixups[0].exp.X_add_symbol,
2173 fixups[0].exp.X_add_number,
2174 (char *) fixups[0].opindex);
2175 md_number_to_chars (f, insn, insn_size);
2176 md_number_to_chars (f + 2, 0, 4);
2178 total_insn_size = insn_size;
2182 /* Four byte insns have an opcode with the two high bits on. */
2183 if ((insn & 0x0600) == 0x0600)
2188 /* Special case: 32 bit MOV. */
2189 if ((insn & 0xffe0) == 0x0620)
2192 f = frag_more (insn_size);
2193 total_insn_size = insn_size;
2195 md_number_to_chars (f, insn, insn_size);
2197 if (extra_data_after_insn)
2199 f = frag_more (extra_data_len);
2200 total_insn_size += extra_data_len;
2202 md_number_to_chars (f, extra_data, extra_data_len);
2204 extra_data_after_insn = false;
2208 /* Create any fixups. At this point we do not use a
2209 bfd_reloc_code_real_type, but instead just use the
2210 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2211 handle fixups for any operand type, although that is admittedly
2212 not a very exciting feature. We pick a BFD reloc type in
2214 for (i = 0; i < fc; i++)
2216 const struct v850_operand *operand;
2217 bfd_reloc_code_real_type reloc;
2219 operand = &v850_operands[fixups[i].opindex];
2221 reloc = fixups[i].reloc;
2223 if (reloc != BFD_RELOC_UNUSED)
2225 reloc_howto_type *reloc_howto =
2226 bfd_reloc_type_lookup (stdoutput, reloc);
2234 size = bfd_get_reloc_size (reloc_howto);
2236 /* XXX This will abort on an R_V850_8 reloc -
2237 is this reloc actually used? */
2238 if (size != 2 && size != 4)
2241 address = (f - frag_now->fr_literal) + insn_size - size;
2243 if (reloc == BFD_RELOC_32)
2246 fixP = fix_new_exp (frag_now, address, size,
2248 reloc_howto->pc_relative,
2253 case BFD_RELOC_LO16:
2254 case BFD_RELOC_HI16:
2255 case BFD_RELOC_HI16_S:
2256 fixP->fx_no_overflow = 1;
2264 fix_new_exp (frag_now,
2265 f - frag_now->fr_literal, 4,
2267 1 /* FIXME: V850_OPERAND_RELATIVE ??? */,
2268 (bfd_reloc_code_real_type) (fixups[i].opindex
2269 + (int) BFD_RELOC_UNUSED));
2273 input_line_pointer = saved_input_line_pointer;
2275 dwarf2_emit_insn (total_insn_size);
2278 /* If while processing a fixup, a reloc really needs to be created
2279 then it is done here. */
2282 tc_gen_reloc (seg, fixp)
2283 asection *seg ATTRIBUTE_UNUSED;
2288 reloc = (arelent *) xmalloc (sizeof (arelent));
2289 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2290 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2291 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2292 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2294 if (reloc->howto == (reloc_howto_type *) NULL)
2296 as_bad_where (fixp->fx_file, fixp->fx_line,
2297 /* xgettext:c-format */
2298 _("reloc %d not supported by object file format"),
2299 (int) fixp->fx_r_type);
2306 if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
2307 || fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT)
2308 reloc->addend = fixp->fx_offset;
2310 reloc->addend = fixp->fx_addnumber;
2315 /* Return current size of variable part of frag. */
2318 md_estimate_size_before_relax (fragp, seg)
2320 asection *seg ATTRIBUTE_UNUSED;
2322 if (fragp->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
2325 return md_relax_table[fragp->fr_subtype].rlx_length;
2329 v850_pcrel_from_section (fixp, section)
2333 /* If the symbol is undefined, or in a section other than our own,
2334 or it is weak (in which case it may well be in another section,
2335 then let the linker figure it out. */
2336 if (fixp->fx_addsy != (symbolS *) NULL
2337 && (! S_IS_DEFINED (fixp->fx_addsy)
2338 || S_IS_WEAK (fixp->fx_addsy)
2339 || (S_GET_SEGMENT (fixp->fx_addsy) != section)))
2342 return fixp->fx_frag->fr_address + fixp->fx_where;
2346 md_apply_fix3 (fixp, valuep, seg)
2349 segT seg ATTRIBUTE_UNUSED;
2354 if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2355 || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2361 if (fixp->fx_addsy == (symbolS *) NULL)
2366 else if (fixp->fx_pcrel)
2370 value = fixp->fx_offset;
2371 if (fixp->fx_subsy != (symbolS *) NULL)
2373 if (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
2374 value -= S_GET_VALUE (fixp->fx_subsy);
2377 /* We don't actually support subtracting a symbol. */
2378 as_bad_where (fixp->fx_file, fixp->fx_line,
2379 _("expression too complex"));
2384 if ((int) fixp->fx_r_type >= (int) BFD_RELOC_UNUSED)
2387 const struct v850_operand *operand;
2390 opindex = (int) fixp->fx_r_type - (int) BFD_RELOC_UNUSED;
2391 operand = &v850_operands[opindex];
2393 /* Fetch the instruction, insert the fully resolved operand
2394 value, and stuff the instruction back again.
2396 Note the instruction has been stored in little endian
2398 where = fixp->fx_frag->fr_literal + fixp->fx_where;
2400 insn = bfd_getl32 ((unsigned char *) where);
2401 insn = v850_insert_operand (insn, operand, (offsetT) value,
2402 fixp->fx_file, fixp->fx_line, NULL);
2403 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
2407 /* Nothing else to do here. */
2411 /* Determine a BFD reloc value based on the operand information.
2412 We are only prepared to turn a few of the operands into relocs. */
2414 if (operand->bits == 22)
2415 fixp->fx_r_type = BFD_RELOC_V850_22_PCREL;
2416 else if (operand->bits == 9)
2417 fixp->fx_r_type = BFD_RELOC_V850_9_PCREL;
2421 fprintf (stderr, "bits: %d, insn: %x\n", operand->bits, insn);
2424 as_bad_where (fixp->fx_file, fixp->fx_line,
2425 _("unresolved expression that must be resolved"));
2430 else if (fixp->fx_done)
2432 /* We still have to insert the value into memory! */
2433 where = fixp->fx_frag->fr_literal + fixp->fx_where;
2435 if (fixp->fx_size == 1)
2436 *where = value & 0xff;
2437 else if (fixp->fx_size == 2)
2438 bfd_putl16 (value & 0xffff, (unsigned char *) where);
2439 else if (fixp->fx_size == 4)
2440 bfd_putl32 (value, (unsigned char *) where);
2443 fixp->fx_addnumber = value;
2447 /* Parse a cons expression. We have to handle hi(), lo(), etc
2451 parse_cons_expression_v850 (exp)
2454 /* See if there's a reloc prefix like hi() we have to handle. */
2455 hold_cons_reloc = v850_reloc_prefix (NULL);
2457 /* Do normal expression parsing. */
2461 /* Create a fixup for a cons expression. If parse_cons_expression_v850
2462 found a reloc prefix, then we use that reloc, else we choose an
2463 appropriate one based on the size of the expression. */
2466 cons_fix_new_v850 (frag, where, size, exp)
2472 if (hold_cons_reloc == BFD_RELOC_UNUSED)
2475 hold_cons_reloc = BFD_RELOC_32;
2477 hold_cons_reloc = BFD_RELOC_16;
2479 hold_cons_reloc = BFD_RELOC_8;
2483 fix_new_exp (frag, where, size, exp, 0, hold_cons_reloc);
2485 fix_new (frag, where, size, NULL, 0, 0, hold_cons_reloc);
2487 hold_cons_reloc = BFD_RELOC_UNUSED;
2491 v850_fix_adjustable (fixP)
2494 if (fixP->fx_addsy == NULL)
2497 /* Prevent all adjustments to global symbols. */
2498 if (S_IS_EXTERN (fixP->fx_addsy))
2501 /* Similarly for weak symbols. */
2502 if (S_IS_WEAK (fixP->fx_addsy))
2505 /* Don't adjust function names. */
2506 if (S_IS_FUNCTION (fixP->fx_addsy))
2509 /* We need the symbol name for the VTABLE entries. */
2510 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2511 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2518 v850_force_relocation (fixP)
2521 if (fixP->fx_addsy && S_IS_WEAK (fixP->fx_addsy))
2524 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2525 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)