1 /* tc-v850.c -- Assembler code for the NEC V850
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
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 boolean warn_signed_overflows = FALSE;
37 static 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;
196 int temp = get_absolute_expression ();
198 temp -= frag_now_fix ();
201 (void) frag_more (temp);
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[] = {
523 { "sdata", v850_seg, SDATA_SECTION },
524 { "tdata", v850_seg, TDATA_SECTION },
525 { "zdata", v850_seg, ZDATA_SECTION },
526 { "sbss", v850_seg, SBSS_SECTION },
527 { "tbss", v850_seg, TBSS_SECTION },
528 { "zbss", v850_seg, ZBSS_SECTION },
529 { "rosdata", v850_seg, ROSDATA_SECTION },
530 { "rozdata", v850_seg, ROZDATA_SECTION },
531 { "bss", v850_seg, BSS_SECTION },
532 { "offset", v850_offset, 0 },
534 { "zcomm", v850_comm, ZCOMMON_SECTION },
535 { "scomm", v850_comm, SCOMMON_SECTION },
536 { "tcomm", v850_comm, TCOMMON_SECTION },
537 { "v850", set_machine, 0 },
538 { "call_table_data", v850_seg, CALL_TABLE_DATA_SECTION },
539 { "call_table_text", v850_seg, CALL_TABLE_TEXT_SECTION },
540 { "v850e", set_machine, bfd_mach_v850e },
541 { "file", (void (*) PARAMS ((int))) dwarf2_directive_file, 0 },
542 { "loc", dwarf2_directive_loc, 0 },
543 { "longcall", v850_longcode, 1 },
544 { "longjump", v850_longcode, 2 },
548 /* Opcode hash table. */
549 static struct hash_control *v850_hash;
551 /* This table is sorted. Suitable for searching by a binary search. */
552 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[] = {
611 #define SYSREG_NAME_CNT \
612 (sizeof (system_registers) / sizeof (struct reg_name))
614 static const struct reg_name system_list_registers[] = {
619 #define SYSREGLIST_NAME_CNT \
620 (sizeof (system_list_registers) / sizeof (struct reg_name))
622 static const struct reg_name cc_names[] = {
647 #define CC_NAME_CNT \
648 (sizeof (cc_names) / sizeof (struct reg_name))
650 /* Do a binary search of the given register table to see if NAME is a
651 valid regiter name. Return the register number from the array on
652 success, or -1 on failure. */
654 static int reg_name_search
655 PARAMS ((const struct reg_name *, int, const char *, boolean));
658 reg_name_search (regs, regcount, name, accept_numbers)
659 const struct reg_name *regs;
662 boolean accept_numbers;
664 int middle, low, high;
668 /* If the register name is a symbol, then evaluate it. */
669 if ((symbolP = symbol_find (name)) != NULL)
671 /* If the symbol is an alias for another name then use that.
672 If the symbol is an alias for a number, then return the number. */
673 if (symbol_equated_p (symbolP))
676 = S_GET_NAME (symbol_get_value_expression (symbolP)->X_add_symbol);
678 else if (accept_numbers)
680 int reg = S_GET_VALUE (symbolP);
682 if (reg >= 0 && reg <= 31)
686 /* Otherwise drop through and try parsing name normally. */
694 middle = (low + high) / 2;
695 cmp = strcasecmp (name, regs[middle].name);
701 return regs[middle].value;
707 /* Summary of register_name().
709 * in: Input_line_pointer points to 1st char of operand.
711 * out: An expressionS.
712 * The operand may have been a register: in this case, X_op == O_register,
713 * X_add_number is set to the register number, and truth is returned.
714 * Input_line_pointer->(next non-blank) char after operand, or is in
715 * its original state. */
717 static boolean register_name PARAMS ((expressionS *));
720 register_name (expressionP)
721 expressionS *expressionP;
728 /* Find the spelling of the operand. */
729 start = name = input_line_pointer;
731 c = get_symbol_end ();
733 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT,
736 /* Put back the delimiting char. */
737 *input_line_pointer = c;
739 /* Look to see if it's in the register table. */
742 expressionP->X_op = O_register;
743 expressionP->X_add_number = reg_number;
745 /* Make the rest nice. */
746 expressionP->X_add_symbol = NULL;
747 expressionP->X_op_symbol = NULL;
753 /* Reset the line as if we had not done anything. */
754 input_line_pointer = start;
760 /* Summary of system_register_name().
762 * in: INPUT_LINE_POINTER points to 1st char of operand.
763 * EXPRESSIONP points to an expression structure to be filled in.
764 * ACCEPT_NUMBERS is true iff numerical register names may be used.
765 * ACCEPT_LIST_NAMES is true iff the special names PS and SR may be
768 * out: An expressionS structure in expressionP.
769 * The operand may have been a register: in this case, X_op == O_register,
770 * X_add_number is set to the register number, and truth is returned.
771 * Input_line_pointer->(next non-blank) char after operand, or is in
772 * its original state. */
774 static boolean system_register_name PARAMS ((expressionS *, boolean, boolean));
777 system_register_name (expressionP, accept_numbers, accept_list_names)
778 expressionS *expressionP;
779 boolean accept_numbers;
780 boolean accept_list_names;
787 /* Find the spelling of the operand. */
788 start = name = input_line_pointer;
790 c = get_symbol_end ();
791 reg_number = reg_name_search (system_registers, SYSREG_NAME_CNT, name,
794 /* Put back the delimiting char. */
795 *input_line_pointer = c;
800 /* Reset input_line pointer. */
801 input_line_pointer = start;
803 if (ISDIGIT (*input_line_pointer))
805 reg_number = strtol (input_line_pointer, &input_line_pointer, 10);
807 /* Make sure that the register number is allowable. */
809 || (reg_number > 5 && reg_number < 16)
815 else if (accept_list_names)
817 c = get_symbol_end ();
818 reg_number = reg_name_search (system_list_registers,
819 SYSREGLIST_NAME_CNT, name, FALSE);
821 /* Put back the delimiting char. */
822 *input_line_pointer = c;
826 /* Look to see if it's in the register table. */
829 expressionP->X_op = O_register;
830 expressionP->X_add_number = reg_number;
832 /* Make the rest nice. */
833 expressionP->X_add_symbol = NULL;
834 expressionP->X_op_symbol = NULL;
840 /* Reset the line as if we had not done anything. */
841 input_line_pointer = start;
847 /* Summary of cc_name().
849 * in: INPUT_LINE_POINTER points to 1st char of operand.
851 * out: An expressionS.
852 * The operand may have been a register: in this case, X_op == O_register,
853 * X_add_number is set to the register number, and truth is returned.
854 * Input_line_pointer->(next non-blank) char after operand, or is in
855 * its original state. */
857 static boolean cc_name PARAMS ((expressionS *));
860 cc_name (expressionP)
861 expressionS *expressionP;
868 /* Find the spelling of the operand. */
869 start = name = input_line_pointer;
871 c = get_symbol_end ();
872 reg_number = reg_name_search (cc_names, CC_NAME_CNT, name, FALSE);
874 /* Put back the delimiting char. */
875 *input_line_pointer = c;
877 /* Look to see if it's in the register table. */
880 expressionP->X_op = O_constant;
881 expressionP->X_add_number = reg_number;
883 /* Make the rest nice. */
884 expressionP->X_add_symbol = NULL;
885 expressionP->X_op_symbol = NULL;
891 /* Reset the line as if we had not done anything. */
892 input_line_pointer = start;
898 static void skip_white_space PARAMS ((void));
903 while (*input_line_pointer == ' '
904 || *input_line_pointer == '\t')
905 ++input_line_pointer;
908 /* Summary of parse_register_list ().
910 * in: INPUT_LINE_POINTER points to 1st char of a list of registers.
911 * INSN is the partially constructed instruction.
912 * OPERAND is the operand being inserted.
914 * out: NULL if the parse completed successfully, otherwise a
915 * pointer to an error message is returned. If the parse
916 * completes the correct bit fields in the instruction
919 * Parses register lists with the syntax:
927 * and also parses constant epxressions whoes bits indicate the
928 * registers in the lists. The LSB in the expression refers to
929 * the lowest numbered permissable register in the register list,
930 * and so on upwards. System registers are considered to be very
933 static char *parse_register_list
934 PARAMS ((unsigned long *, const struct v850_operand *));
937 parse_register_list (insn, operand)
939 const struct v850_operand *operand;
941 static int type1_regs[32] = {
942 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
943 0, 0, 0, 0, 0, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
945 static int type2_regs[32] = {
946 19, 18, 17, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
947 0, 0, 0, 0, 30, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24
949 static int type3_regs[32] = {
950 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
951 0, 0, 0, 0, 14, 15, 13, 12, 7, 6, 5, 4, 11, 10, 9, 8
956 /* Select a register array to parse. */
957 switch (operand->shift)
959 case 0xffe00001: regs = type1_regs; break;
960 case 0xfff8000f: regs = type2_regs; break;
961 case 0xfff8001f: regs = type3_regs; break;
963 as_bad (_("unknown operand shift: %x\n"), operand->shift);
964 return _("internal failure in parse_register_list");
969 /* If the expression starts with a curly brace it is a register list.
970 Otherwise it is a constant expression, whoes bits indicate which
971 registers are to be included in the list. */
973 if (*input_line_pointer != '{')
980 if (exp.X_op != O_constant)
981 return _("constant expression or register list expected");
983 if (regs == type1_regs)
985 if (exp.X_add_number & 0xFFFFF000)
986 return _("high bits set in register list expression");
988 for (reg = 20; reg < 32; reg++)
989 if (exp.X_add_number & (1 << (reg - 20)))
991 for (i = 0; i < 32; i++)
996 else if (regs == type2_regs)
998 if (exp.X_add_number & 0xFFFE0000)
999 return _("high bits set in register list expression");
1001 for (reg = 1; reg < 16; reg++)
1002 if (exp.X_add_number & (1 << (reg - 1)))
1004 for (i = 0; i < 32; i++)
1009 if (exp.X_add_number & (1 << 15))
1012 if (exp.X_add_number & (1 << 16))
1015 else /* regs == type3_regs */
1017 if (exp.X_add_number & 0xFFFE0000)
1018 return _("high bits set in register list expression");
1020 for (reg = 16; reg < 32; reg++)
1021 if (exp.X_add_number & (1 << (reg - 16)))
1023 for (i = 0; i < 32; i++)
1028 if (exp.X_add_number & (1 << 16))
1035 input_line_pointer++;
1037 /* Parse the register list until a terminator (closing curly brace or
1038 new-line) is found. */
1041 if (register_name (&exp))
1045 /* Locate the given register in the list, and if it is there,
1046 insert the corresponding bit into the instruction. */
1047 for (i = 0; i < 32; i++)
1049 if (regs[i] == exp.X_add_number)
1058 return _("illegal register included in list");
1061 else if (system_register_name (&exp, true, true))
1063 if (regs == type1_regs)
1065 return _("system registers cannot be included in list");
1067 else if (exp.X_add_number == 5)
1069 if (regs == type2_regs)
1070 return _("PSW cannot be included in list");
1074 else if (exp.X_add_number < 4)
1077 return _("High value system registers cannot be included in list");
1079 else if (*input_line_pointer == '}')
1081 input_line_pointer++;
1084 else if (*input_line_pointer == ',')
1086 input_line_pointer++;
1089 else if (*input_line_pointer == '-')
1091 /* We have encountered a range of registers: rX - rY. */
1095 /* Skip the dash. */
1096 ++input_line_pointer;
1098 /* Get the second register in the range. */
1099 if (! register_name (&exp2))
1101 return _("second register should follow dash in register list");
1102 exp2.X_add_number = exp.X_add_number;
1105 /* Add the rest of the registers in the range. */
1106 for (j = exp.X_add_number + 1; j <= exp2.X_add_number; j++)
1110 /* Locate the given register in the list, and if it is there,
1111 insert the corresponding bit into the instruction. */
1112 for (i = 0; i < 32; i++)
1122 return _("illegal register included in list");
1130 skip_white_space ();
1136 const char *md_shortopts = "m:";
1138 struct option md_longopts[] = {
1139 {NULL, no_argument, NULL, 0}
1142 size_t md_longopts_size = sizeof (md_longopts);
1145 md_show_usage (stream)
1148 fprintf (stream, _(" V850 options:\n"));
1149 fprintf (stream, _(" -mwarn-signed-overflow Warn if signed immediate values overflow\n"));
1150 fprintf (stream, _(" -mwarn-unsigned-overflow Warn if unsigned immediate values overflow\n"));
1151 fprintf (stream, _(" -mv850 The code is targeted at the v850\n"));
1152 fprintf (stream, _(" -mv850e The code is targeted at the v850e\n"));
1153 fprintf (stream, _(" -mv850any The code is generic, despite any processor specific instructions\n"));
1154 fprintf (stream, _(" -mrelax Enable relaxation\n"));
1159 md_parse_option (c, arg)
1166 /* xgettext:c-format */
1167 fprintf (stderr, _("unknown command line option: -%c%s\n"), c, arg);
1171 if (strcmp (arg, "warn-signed-overflow") == 0)
1173 warn_signed_overflows = TRUE;
1175 else if (strcmp (arg, "warn-unsigned-overflow") == 0)
1177 warn_unsigned_overflows = TRUE;
1179 else if (strcmp (arg, "v850") == 0)
1182 processor_mask = PROCESSOR_V850;
1184 else if (strcmp (arg, "v850e") == 0)
1186 machine = bfd_mach_v850e;
1187 processor_mask = PROCESSOR_V850E;
1189 else if (strcmp (arg, "v850any") == 0)
1191 /* Tell the world that this is for any v850 chip. */
1194 /* But support instructions for the extended versions. */
1195 processor_mask = PROCESSOR_V850E;
1197 else if (strcmp (arg, "relax") == 0)
1201 /* xgettext:c-format */
1202 fprintf (stderr, _("unknown command line option: -%c%s\n"), c, arg);
1210 md_undefined_symbol (name)
1211 char *name ATTRIBUTE_UNUSED;
1217 md_atof (type, litp, sizep)
1223 LITTLENUM_TYPE words[4];
1239 return _("bad call to md_atof");
1242 t = atof_ieee (input_line_pointer, type, words);
1244 input_line_pointer = t;
1248 for (i = prec - 1; i >= 0; i--)
1250 md_number_to_chars (litp, (valueT) words[i], 2);
1260 md_convert_frag (abfd, sec, fragP)
1261 bfd *abfd ATTRIBUTE_UNUSED;
1265 subseg_change (sec, 0);
1267 /* In range conditional or unconditional branch. */
1268 if (fragP->fr_subtype == 0 || fragP->fr_subtype == 2)
1270 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
1271 fragP->fr_offset, 1, BFD_RELOC_UNUSED + (int)fragP->fr_opcode);
1274 /* Out of range conditional branch. Emit a branch around a jump. */
1275 else if (fragP->fr_subtype == 1)
1277 unsigned char *buffer =
1278 (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1280 /* Reverse the condition of the first branch. */
1282 /* Mask off all the displacement bits. */
1285 /* Now set the displacement bits so that we branch
1286 around the unconditional branch. */
1289 /* Now create the unconditional branch + fixup to the final
1291 md_number_to_chars (buffer + 2, 0x00000780, 4);
1292 fix_new (fragP, fragP->fr_fix + 2, 4, fragP->fr_symbol,
1293 fragP->fr_offset, 1, BFD_RELOC_UNUSED +
1294 (int) fragP->fr_opcode + 1);
1297 /* Out of range unconditional branch. Emit a jump. */
1298 else if (fragP->fr_subtype == 3)
1300 md_number_to_chars (fragP->fr_fix + fragP->fr_literal, 0x00000780, 4);
1301 fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
1302 fragP->fr_offset, 1, BFD_RELOC_UNUSED +
1303 (int) fragP->fr_opcode + 1);
1311 md_section_align (seg, addr)
1315 int align = bfd_get_section_alignment (stdoutput, seg);
1316 return ((addr + (1 << align) - 1) & (-1 << align));
1322 char *prev_name = "";
1323 const struct v850_opcode *op;
1325 if (strncmp (TARGET_CPU, "v850e", 5) == 0)
1328 machine = bfd_mach_v850e;
1330 if (processor_mask == -1)
1331 processor_mask = PROCESSOR_V850E;
1333 else if (strncmp (TARGET_CPU, "v850", 4) == 0)
1338 if (processor_mask == -1)
1339 processor_mask = PROCESSOR_V850;
1342 /* xgettext:c-format */
1343 as_bad (_("Unable to determine default target processor from string: %s"),
1346 v850_hash = hash_new ();
1348 /* Insert unique names into hash table. The V850 instruction set
1349 has many identical opcode names that have different opcodes based
1350 on the operands. This hash table then provides a quick index to
1351 the first opcode with a particular name in the opcode table. */
1356 if (strcmp (prev_name, op->name))
1358 prev_name = (char *) op->name;
1359 hash_insert (v850_hash, op->name, (char *) op);
1364 v850_seg_table[BSS_SECTION].s = bss_section;
1365 bfd_set_arch_mach (stdoutput, TARGET_ARCH, machine);
1368 static bfd_reloc_code_real_type handle_ctoff
1369 PARAMS ((const struct v850_operand *));
1371 static bfd_reloc_code_real_type
1372 handle_ctoff (operand)
1373 const struct v850_operand *operand;
1375 if (operand == NULL)
1376 return BFD_RELOC_V850_CALLT_16_16_OFFSET;
1378 if (operand->bits != 6
1379 || operand->shift != 0)
1381 as_bad (_("ctoff() relocation used on an instruction which does not support it"));
1382 return BFD_RELOC_64; /* Used to indicate an error condition. */
1385 return BFD_RELOC_V850_CALLT_6_7_OFFSET;
1388 static bfd_reloc_code_real_type handle_sdaoff
1389 PARAMS ((const struct v850_operand *));
1391 static bfd_reloc_code_real_type
1392 handle_sdaoff (operand)
1393 const struct v850_operand *operand;
1395 if (operand == NULL)
1396 return BFD_RELOC_V850_SDA_16_16_OFFSET;
1398 if (operand->bits == 15 && operand->shift == 17)
1399 return BFD_RELOC_V850_SDA_15_16_OFFSET;
1401 if (operand->bits == -1)
1402 return BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET;
1404 if (operand->bits != 16
1405 || operand->shift != 16)
1407 as_bad (_("sdaoff() relocation used on an instruction which does not support it"));
1408 return BFD_RELOC_64; /* Used to indicate an error condition. */
1411 return BFD_RELOC_V850_SDA_16_16_OFFSET;
1414 static bfd_reloc_code_real_type handle_zdaoff
1415 PARAMS ((const struct v850_operand *));
1417 static bfd_reloc_code_real_type
1418 handle_zdaoff (operand)
1419 const struct v850_operand *operand;
1421 if (operand == NULL)
1422 return BFD_RELOC_V850_ZDA_16_16_OFFSET;
1424 if (operand->bits == 15 && operand->shift == 17)
1425 return BFD_RELOC_V850_ZDA_15_16_OFFSET;
1427 if (operand->bits == -1)
1428 return BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET;
1430 if (operand->bits != 16
1431 || operand->shift != 16)
1433 as_bad (_("zdaoff() relocation used on an instruction which does not support it"));
1434 /* Used to indicate an error condition. */
1435 return BFD_RELOC_64;
1438 return BFD_RELOC_V850_ZDA_16_16_OFFSET;
1441 static bfd_reloc_code_real_type handle_tdaoff
1442 PARAMS ((const struct v850_operand *));
1444 static bfd_reloc_code_real_type
1445 handle_tdaoff (operand)
1446 const struct v850_operand *operand;
1448 if (operand == NULL)
1449 /* Data item, not an instruction. */
1450 return BFD_RELOC_V850_TDA_7_7_OFFSET;
1452 if (operand->bits == 6 && operand->shift == 1)
1453 /* sld.w/sst.w, operand: D8_6 */
1454 return BFD_RELOC_V850_TDA_6_8_OFFSET;
1456 if (operand->bits == 4 && operand->insert != NULL)
1457 /* sld.hu, operand: D5-4 */
1458 return BFD_RELOC_V850_TDA_4_5_OFFSET;
1460 if (operand->bits == 4 && operand->insert == NULL)
1461 /* sld.bu, operand: D4 */
1462 return BFD_RELOC_V850_TDA_4_4_OFFSET;
1464 if (operand->bits == 16 && operand->shift == 16)
1465 /* set1 & chums, operands: D16 */
1466 return BFD_RELOC_V850_TDA_16_16_OFFSET;
1468 if (operand->bits != 7)
1470 as_bad (_("tdaoff() relocation used on an instruction which does not support it"));
1471 /* Used to indicate an error condition. */
1472 return BFD_RELOC_64;
1475 return operand->insert != NULL
1476 ? BFD_RELOC_V850_TDA_7_8_OFFSET /* sld.h/sst.h, operand: D8_7 */
1477 : BFD_RELOC_V850_TDA_7_7_OFFSET; /* sld.b/sst.b, opreand: D7 */
1480 /* Warning: The code in this function relies upon the definitions
1481 in the v850_operands[] array (defined in opcodes/v850-opc.c)
1482 matching the hard coded values contained herein. */
1484 static bfd_reloc_code_real_type v850_reloc_prefix
1485 PARAMS ((const struct v850_operand *));
1487 static bfd_reloc_code_real_type
1488 v850_reloc_prefix (operand)
1489 const struct v850_operand *operand;
1491 boolean paren_skipped = false;
1493 /* Skip leading opening parenthesis. */
1494 if (*input_line_pointer == '(')
1496 ++input_line_pointer;
1497 paren_skipped = true;
1500 #define CHECK_(name, reloc) \
1501 if (strncmp (input_line_pointer, name##"(", strlen (name) + 1) == 0) \
1503 input_line_pointer += strlen (name); \
1507 CHECK_ ("hi0", BFD_RELOC_HI16 );
1508 CHECK_ ("hi", BFD_RELOC_HI16_S );
1509 CHECK_ ("lo", BFD_RELOC_LO16 );
1510 CHECK_ ("sdaoff", handle_sdaoff (operand));
1511 CHECK_ ("zdaoff", handle_zdaoff (operand));
1512 CHECK_ ("tdaoff", handle_tdaoff (operand));
1513 CHECK_ ("hilo", BFD_RELOC_32 );
1514 CHECK_ ("ctoff", handle_ctoff (operand) );
1516 /* Restore skipped parenthesis. */
1518 --input_line_pointer;
1520 return BFD_RELOC_UNUSED;
1523 /* Insert an operand value into an instruction. */
1525 static unsigned long v850_insert_operand
1526 PARAMS ((unsigned long, const struct v850_operand *, offsetT, char *,
1527 unsigned int, char *));
1529 static unsigned long
1530 v850_insert_operand (insn, operand, val, file, line, str)
1532 const struct v850_operand *operand;
1538 if (operand->insert)
1540 const char *message = NULL;
1542 insn = operand->insert (insn, val, &message);
1543 if (message != NULL)
1545 if ((operand->flags & V850_OPERAND_SIGNED)
1546 && ! warn_signed_overflows
1547 && strstr (message, "out of range") != NULL)
1549 /* Skip warning... */
1551 else if ((operand->flags & V850_OPERAND_SIGNED) == 0
1552 && ! warn_unsigned_overflows
1553 && strstr (message, "out of range") != NULL)
1555 /* Skip warning... */
1559 if (file == (char *) NULL)
1560 as_warn ("%s: %s", str, message);
1562 as_warn_where (file, line, "%s: %s", str, message);
1566 if (file == (char *) NULL)
1569 as_warn_where (file, line, message);
1575 if (operand->bits != 32)
1579 if ((operand->flags & V850_OPERAND_SIGNED) != 0)
1581 if (! warn_signed_overflows)
1582 max = (1 << operand->bits) - 1;
1584 max = (1 << (operand->bits - 1)) - 1;
1586 min = -(1 << (operand->bits - 1));
1590 max = (1 << operand->bits) - 1;
1592 if (! warn_unsigned_overflows)
1593 min = -(1 << (operand->bits - 1));
1598 if (val < (offsetT) min || val > (offsetT) max)
1600 /* xgettext:c-format */
1602 _("operand out of range (%s not between %ld and %ld)");
1605 /* Restore min and mix to expected values for decimal ranges. */
1606 if ((operand->flags & V850_OPERAND_SIGNED)
1607 && ! warn_signed_overflows)
1608 max = (1 << (operand->bits - 1)) - 1;
1610 if (! (operand->flags & V850_OPERAND_SIGNED)
1611 && ! warn_unsigned_overflows)
1616 sprintf (buf, "%s: ", str);
1618 sprint_value (buf + strlen (buf), val);
1621 sprint_value (buf, val);
1623 if (file == (char *) NULL)
1624 as_warn (err, buf, min, max);
1626 as_warn_where (file, line, err, buf, min, max);
1630 insn |= (((long) val & ((1 << operand->bits) - 1)) << operand->shift);
1636 static char copy_of_instruction[128];
1643 char *start_of_operands;
1644 struct v850_opcode *opcode;
1645 struct v850_opcode *next_opcode;
1646 const unsigned char *opindex_ptr;
1650 unsigned long insn_size;
1654 boolean extra_data_after_insn = false;
1655 unsigned extra_data_len = 0;
1656 unsigned long extra_data = 0;
1657 char *saved_input_line_pointer;
1659 strncpy (copy_of_instruction, str, sizeof (copy_of_instruction) - 1);
1661 /* Get the opcode. */
1662 for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
1668 /* Find the first opcode with the proper name. */
1669 opcode = (struct v850_opcode *) hash_find (v850_hash, str);
1672 /* xgettext:c-format */
1673 as_bad (_("Unrecognized opcode: `%s'"), str);
1674 ignore_rest_of_line ();
1679 while (ISSPACE (*str))
1682 start_of_operands = str;
1684 saved_input_line_pointer = input_line_pointer;
1688 const char *errmsg = NULL;
1692 if ((opcode->processors & processor_mask) == 0)
1694 errmsg = _("Target processor does not support this instruction.");
1701 insn = opcode->opcode;
1702 extra_data_after_insn = false;
1704 input_line_pointer = str = start_of_operands;
1706 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1708 const struct v850_operand *operand;
1711 bfd_reloc_code_real_type reloc;
1713 if (next_opindex == 0)
1715 operand = &v850_operands[*opindex_ptr];
1719 operand = &v850_operands[next_opindex];
1725 while (*str == ' ' || *str == ',' || *str == '[' || *str == ']')
1728 if (operand->flags & V850_OPERAND_RELAX)
1731 /* Gather the operand. */
1732 hold = input_line_pointer;
1733 input_line_pointer = str;
1735 /* lo(), hi(), hi0(), etc... */
1736 if ((reloc = v850_reloc_prefix (operand)) != BFD_RELOC_UNUSED)
1738 /* This is a fake reloc, used to indicate an error condition. */
1739 if (reloc == BFD_RELOC_64)
1747 if (ex.X_op == O_constant)
1751 case BFD_RELOC_V850_ZDA_16_16_OFFSET:
1752 /* To cope with "not1 7, zdaoff(0xfffff006)[r0]"
1756 case BFD_RELOC_LO16:
1758 /* Truncate, then sign extend the value. */
1759 ex.X_add_number = SEXT16 (ex.X_add_number);
1763 case BFD_RELOC_HI16:
1765 /* Truncate, then sign extend the value. */
1766 ex.X_add_number = SEXT16 (ex.X_add_number >> 16);
1770 case BFD_RELOC_HI16_S:
1772 /* Truncate, then sign extend the value. */
1773 int temp = (ex.X_add_number >> 16) & 0xffff;
1775 temp += (ex.X_add_number >> 15) & 1;
1777 ex.X_add_number = SEXT16 (temp);
1782 if ((operand->flags & V850E_IMMEDIATE32) == 0)
1784 errmsg = _("immediate operand is too large");
1788 extra_data_after_insn = true;
1794 fprintf (stderr, "reloc: %d\n", reloc);
1795 as_bad (_("AAARG -> unhandled constant reloc"));
1799 if (fc > MAX_INSN_FIXUPS)
1800 as_fatal (_("too many fixups"));
1802 fixups[fc].exp = ex;
1803 fixups[fc].opindex = *opindex_ptr;
1804 fixups[fc].reloc = reloc;
1809 if (reloc == BFD_RELOC_32)
1811 if ((operand->flags & V850E_IMMEDIATE32) == 0)
1813 errmsg = _("immediate operand is too large");
1817 extra_data_after_insn = true;
1819 extra_data = ex.X_add_number;
1822 if (fc > MAX_INSN_FIXUPS)
1823 as_fatal (_("too many fixups"));
1825 fixups[fc].exp = ex;
1826 fixups[fc].opindex = *opindex_ptr;
1827 fixups[fc].reloc = reloc;
1835 if ((operand->flags & V850_OPERAND_REG) != 0)
1837 if (!register_name (&ex))
1839 errmsg = _("invalid register name");
1841 else if ((operand->flags & V850_NOT_R0)
1842 && ex.X_add_number == 0)
1844 errmsg = _("register r0 cannot be used here");
1846 /* Force an error message to be generated by
1847 skipping over any following potential matches
1852 else if ((operand->flags & V850_OPERAND_SRG) != 0)
1854 if (!system_register_name (&ex, true, false))
1856 errmsg = _("invalid system register name");
1859 else if ((operand->flags & V850_OPERAND_EP) != 0)
1861 char *start = input_line_pointer;
1862 char c = get_symbol_end ();
1864 if (strcmp (start, "ep") != 0 && strcmp (start, "r30") != 0)
1866 /* Put things back the way we found them. */
1867 *input_line_pointer = c;
1868 input_line_pointer = start;
1869 errmsg = _("expected EP register");
1873 *input_line_pointer = c;
1874 str = input_line_pointer;
1875 input_line_pointer = hold;
1877 while (*str == ' ' || *str == ','
1878 || *str == '[' || *str == ']')
1882 else if ((operand->flags & V850_OPERAND_CC) != 0)
1886 errmsg = _("invalid condition code name");
1889 else if (operand->flags & V850E_PUSH_POP)
1891 errmsg = parse_register_list (&insn, operand);
1893 /* The parse_register_list() function has already done
1894 everything, so fake a dummy expression. */
1895 ex.X_op = O_constant;
1896 ex.X_add_number = 0;
1898 else if (operand->flags & V850E_IMMEDIATE16)
1902 if (ex.X_op != O_constant)
1903 errmsg = _("constant expression expected");
1904 else if (ex.X_add_number & 0xffff0000)
1906 if (ex.X_add_number & 0xffff)
1907 errmsg = _("constant too big to fit into instruction");
1908 else if ((insn & 0x001fffc0) == 0x00130780)
1909 ex.X_add_number >>= 16;
1911 errmsg = _("constant too big to fit into instruction");
1914 extra_data_after_insn = true;
1916 extra_data = ex.X_add_number;
1917 ex.X_add_number = 0;
1919 else if (operand->flags & V850E_IMMEDIATE32)
1923 if (ex.X_op != O_constant)
1924 errmsg = _("constant expression expected");
1926 extra_data_after_insn = true;
1928 extra_data = ex.X_add_number;
1929 ex.X_add_number = 0;
1931 else if (register_name (&ex)
1932 && (operand->flags & V850_OPERAND_REG) == 0)
1937 /* It is possible that an alias has been defined that
1938 matches a register name. For example the code may
1939 include a ".set ZERO, 0" directive, which matches
1940 the register name "zero". Attempt to reparse the
1941 field as an expression, and only complain if we
1942 cannot generate a constant. */
1944 input_line_pointer = str;
1946 c = get_symbol_end ();
1948 if (symbol_find (str) != NULL)
1951 *input_line_pointer = c;
1952 input_line_pointer = str;
1956 if (ex.X_op != O_constant)
1958 /* If this register is actually occuring too early on
1959 the parsing of the instruction, (because another
1960 field is missing) then report this. */
1961 if (opindex_ptr[1] != 0
1962 && (v850_operands[opindex_ptr[1]].flags
1963 & V850_OPERAND_REG))
1964 errmsg = _("syntax error: value is missing before the register name");
1966 errmsg = _("syntax error: register not expected");
1968 /* If we created a symbol in the process of this
1969 test then delete it now, so that it will not
1970 be output with the real symbols... */
1972 && ex.X_op == O_symbol)
1973 symbol_remove (ex.X_add_symbol,
1974 &symbol_rootP, &symbol_lastP);
1977 else if (system_register_name (&ex, false, false)
1978 && (operand->flags & V850_OPERAND_SRG) == 0)
1980 errmsg = _("syntax error: system register not expected");
1982 else if (cc_name (&ex)
1983 && (operand->flags & V850_OPERAND_CC) == 0)
1985 errmsg = _("syntax error: condition code not expected");
1991 If we are assembling a MOV instruction and the immediate
1992 value does not fit into the bits available then create a
1993 fake error so that the next MOV instruction will be
1994 selected. This one has a 32 bit immediate field. */
1996 if (((insn & 0x07e0) == 0x0200)
1997 && operand->bits == 5 /* Do not match the CALLT instruction. */
1998 && ex.X_op == O_constant
1999 && (ex.X_add_number < (-(1 << (operand->bits - 1)))
2000 || ex.X_add_number > ((1 << (operand->bits - 1)) - 1)))
2001 errmsg = _("immediate operand is too large");
2009 " insn: %x, operand %d, op: %d, add_number: %d\n",
2010 insn, opindex_ptr - opcode->operands,
2011 ex.X_op, ex.X_add_number);
2017 errmsg = _("illegal operand");
2020 errmsg = _("missing operand");
2024 & (V850_OPERAND_REG | V850_OPERAND_SRG)) == 0)
2026 errmsg = _("invalid operand");
2029 insn = v850_insert_operand (insn, operand, ex.X_add_number,
2031 copy_of_instruction);
2035 insn = v850_insert_operand (insn, operand, ex.X_add_number,
2037 copy_of_instruction);
2041 /* We need to generate a fixup for this expression. */
2042 if (fc >= MAX_INSN_FIXUPS)
2043 as_fatal (_("too many fixups"));
2045 fixups[fc].exp = ex;
2046 fixups[fc].opindex = *opindex_ptr;
2047 fixups[fc].reloc = BFD_RELOC_UNUSED;
2053 str = input_line_pointer;
2054 input_line_pointer = hold;
2056 while (*str == ' ' || *str == ',' || *str == '[' || *str == ']'
2065 next_opcode = opcode + 1;
2066 if (next_opcode->name != NULL
2067 && strcmp (next_opcode->name, opcode->name) == 0)
2069 opcode = next_opcode;
2071 /* Skip versions that are not supported by the target
2073 if ((opcode->processors & processor_mask) == 0)
2079 as_bad ("%s: %s", copy_of_instruction, errmsg);
2081 if (*input_line_pointer == ']')
2082 ++input_line_pointer;
2084 ignore_rest_of_line ();
2085 input_line_pointer = saved_input_line_pointer;
2091 while (ISSPACE (*str))
2095 /* xgettext:c-format */
2096 as_bad (_("junk at end of line: `%s'"), str);
2098 input_line_pointer = str;
2100 /* Tie dwarf2 debug info to the address at the start of the insn.
2101 We can't do this after the insn has been output as the current
2102 frag may have been closed off. eg. by frag_var. */
2103 dwarf2_emit_insn (0);
2105 /* Write out the instruction. */
2107 if (relaxable && fc > 0)
2112 if (!strcmp (opcode->name, "br"))
2114 f = frag_var (rs_machine_dependent, 4, 2, 2,
2115 fixups[0].exp.X_add_symbol,
2116 fixups[0].exp.X_add_number,
2117 (char *) fixups[0].opindex);
2118 md_number_to_chars (f, insn, insn_size);
2119 md_number_to_chars (f + 2, 0, 2);
2123 f = frag_var (rs_machine_dependent, 6, 4, 0,
2124 fixups[0].exp.X_add_symbol,
2125 fixups[0].exp.X_add_number,
2126 (char *) fixups[0].opindex);
2127 md_number_to_chars (f, insn, insn_size);
2128 md_number_to_chars (f + 2, 0, 4);
2133 /* Four byte insns have an opcode with the two high bits on. */
2134 if ((insn & 0x0600) == 0x0600)
2139 /* Special case: 32 bit MOV. */
2140 if ((insn & 0xffe0) == 0x0620)
2143 f = frag_more (insn_size);
2144 md_number_to_chars (f, insn, insn_size);
2146 if (extra_data_after_insn)
2148 f = frag_more (extra_data_len);
2149 md_number_to_chars (f, extra_data, extra_data_len);
2151 extra_data_after_insn = false;
2155 /* Create any fixups. At this point we do not use a
2156 bfd_reloc_code_real_type, but instead just use the
2157 BFD_RELOC_UNUSED plus the operand index. This lets us easily
2158 handle fixups for any operand type, although that is admittedly
2159 not a very exciting feature. We pick a BFD reloc type in
2161 for (i = 0; i < fc; i++)
2163 const struct v850_operand *operand;
2164 bfd_reloc_code_real_type reloc;
2166 operand = &v850_operands[fixups[i].opindex];
2168 reloc = fixups[i].reloc;
2170 if (reloc != BFD_RELOC_UNUSED)
2172 reloc_howto_type *reloc_howto =
2173 bfd_reloc_type_lookup (stdoutput, reloc);
2181 size = bfd_get_reloc_size (reloc_howto);
2183 /* XXX This will abort on an R_V850_8 reloc -
2184 is this reloc actually used? */
2185 if (size != 2 && size != 4)
2188 address = (f - frag_now->fr_literal) + insn_size - size;
2190 if (reloc == BFD_RELOC_32)
2193 fixP = fix_new_exp (frag_now, address, size,
2195 reloc_howto->pc_relative,
2200 case BFD_RELOC_LO16:
2201 case BFD_RELOC_HI16:
2202 case BFD_RELOC_HI16_S:
2203 fixP->fx_no_overflow = 1;
2211 fix_new_exp (frag_now,
2212 f - frag_now->fr_literal, 4,
2214 1 /* FIXME: V850_OPERAND_RELATIVE ??? */,
2215 (bfd_reloc_code_real_type) (fixups[i].opindex
2216 + (int) BFD_RELOC_UNUSED));
2220 input_line_pointer = saved_input_line_pointer;
2223 /* If while processing a fixup, a reloc really needs to be created
2224 then it is done here. */
2227 tc_gen_reloc (seg, fixp)
2228 asection *seg ATTRIBUTE_UNUSED;
2233 reloc = (arelent *) xmalloc (sizeof (arelent));
2234 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2235 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2236 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2237 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2239 if (reloc->howto == (reloc_howto_type *) NULL)
2241 as_bad_where (fixp->fx_file, fixp->fx_line,
2242 /* xgettext:c-format */
2243 _("reloc %d not supported by object file format"),
2244 (int) fixp->fx_r_type);
2251 if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
2252 || fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT)
2253 reloc->addend = fixp->fx_offset;
2254 else if ( fixp->fx_r_type == BFD_RELOC_V850_LONGCALL
2255 || fixp->fx_r_type == BFD_RELOC_V850_LONGJUMP
2256 || fixp->fx_r_type == BFD_RELOC_V850_ALIGN)
2257 reloc->addend = fixp->fx_offset;
2259 reloc->addend = fixp->fx_addnumber;
2265 v850_handle_align (frag)
2269 && frag->fr_type == rs_align
2270 && frag->fr_address + frag->fr_fix > 0
2271 && frag->fr_offset > 1
2272 && now_seg != bss_section
2273 && now_seg != v850_seg_table[SBSS_SECTION].s
2274 && now_seg != v850_seg_table[TBSS_SECTION].s
2275 && now_seg != v850_seg_table[ZBSS_SECTION].s)
2276 fix_new (frag, frag->fr_fix, 2, & abs_symbol, frag->fr_offset, 0,
2277 BFD_RELOC_V850_ALIGN);
2280 /* Return current size of variable part of frag. */
2283 md_estimate_size_before_relax (fragp, seg)
2285 asection *seg ATTRIBUTE_UNUSED;
2287 if (fragp->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
2290 return md_relax_table[fragp->fr_subtype].rlx_length;
2294 v850_pcrel_from_section (fixp, section)
2298 /* If the symbol is undefined, or in a section other than our own,
2299 or it is weak (in which case it may well be in another section,
2300 then let the linker figure it out. */
2301 if (fixp->fx_addsy != (symbolS *) NULL
2302 && (! S_IS_DEFINED (fixp->fx_addsy)
2303 || S_IS_WEAK (fixp->fx_addsy)
2304 || (S_GET_SEGMENT (fixp->fx_addsy) != section)))
2307 return fixp->fx_frag->fr_address + fixp->fx_where;
2311 md_apply_fix3 (fixP, valueP, seg)
2314 segT seg ATTRIBUTE_UNUSED;
2316 valueT value = * valueP;
2319 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2320 || fixP->fx_r_type == BFD_RELOC_V850_LONGCALL
2321 || fixP->fx_r_type == BFD_RELOC_V850_LONGJUMP
2322 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2328 if (fixP->fx_addsy == (symbolS *) NULL)
2329 fixP->fx_addnumber = value,
2332 else if (fixP->fx_pcrel)
2333 fixP->fx_addnumber = fixP->fx_offset;
2337 value = fixP->fx_offset;
2338 if (fixP->fx_subsy != (symbolS *) NULL)
2340 if (S_GET_SEGMENT (fixP->fx_subsy) == absolute_section)
2341 value -= S_GET_VALUE (fixP->fx_subsy);
2344 /* We don't actually support subtracting a symbol. */
2345 as_bad_where (fixP->fx_file, fixP->fx_line,
2346 _("expression too complex"));
2349 fixP->fx_addnumber = value;
2352 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
2355 const struct v850_operand *operand;
2358 opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
2359 operand = &v850_operands[opindex];
2361 /* Fetch the instruction, insert the fully resolved operand
2362 value, and stuff the instruction back again.
2364 Note the instruction has been stored in little endian
2366 where = fixP->fx_frag->fr_literal + fixP->fx_where;
2368 insn = bfd_getl32 ((unsigned char *) where);
2369 insn = v850_insert_operand (insn, operand, (offsetT) value,
2370 fixP->fx_file, fixP->fx_line, NULL);
2371 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
2374 /* Nothing else to do here. */
2377 /* Determine a BFD reloc value based on the operand information.
2378 We are only prepared to turn a few of the operands into relocs. */
2380 if (operand->bits == 22)
2381 fixP->fx_r_type = BFD_RELOC_V850_22_PCREL;
2382 else if (operand->bits == 9)
2383 fixP->fx_r_type = BFD_RELOC_V850_9_PCREL;
2387 fprintf (stderr, "bits: %d, insn: %x\n", operand->bits, insn);
2390 as_bad_where (fixP->fx_file, fixP->fx_line,
2391 _("unresolved expression that must be resolved"));
2396 else if (fixP->fx_done)
2398 /* We still have to insert the value into memory! */
2399 where = fixP->fx_frag->fr_literal + fixP->fx_where;
2401 if (fixP->fx_size == 1)
2402 *where = value & 0xff;
2403 else if (fixP->fx_size == 2)
2404 bfd_putl16 (value & 0xffff, (unsigned char *) where);
2405 else if (fixP->fx_size == 4)
2406 bfd_putl32 (value, (unsigned char *) where);
2410 /* Parse a cons expression. We have to handle hi(), lo(), etc
2414 parse_cons_expression_v850 (exp)
2417 /* See if there's a reloc prefix like hi() we have to handle. */
2418 hold_cons_reloc = v850_reloc_prefix (NULL);
2420 /* Do normal expression parsing. */
2424 /* Create a fixup for a cons expression. If parse_cons_expression_v850
2425 found a reloc prefix, then we use that reloc, else we choose an
2426 appropriate one based on the size of the expression. */
2429 cons_fix_new_v850 (frag, where, size, exp)
2435 if (hold_cons_reloc == BFD_RELOC_UNUSED)
2438 hold_cons_reloc = BFD_RELOC_32;
2440 hold_cons_reloc = BFD_RELOC_16;
2442 hold_cons_reloc = BFD_RELOC_8;
2446 fix_new_exp (frag, where, size, exp, 0, hold_cons_reloc);
2448 fix_new (frag, where, size, NULL, 0, 0, hold_cons_reloc);
2450 hold_cons_reloc = BFD_RELOC_UNUSED;
2454 v850_fix_adjustable (fixP)
2457 if (fixP->fx_addsy == NULL)
2460 /* Prevent all adjustments to global symbols. */
2461 if (S_IS_EXTERN (fixP->fx_addsy))
2464 /* Similarly for weak symbols. */
2465 if (S_IS_WEAK (fixP->fx_addsy))
2468 /* Don't adjust function names. */
2469 if (S_IS_FUNCTION (fixP->fx_addsy))
2472 /* We need the symbol name for the VTABLE entries. */
2473 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2474 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2481 v850_force_relocation (fixP)
2484 if (fixP->fx_addsy && S_IS_WEAK (fixP->fx_addsy))
2487 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2488 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2491 if ( fixP->fx_r_type == BFD_RELOC_V850_LONGCALL
2492 || fixP->fx_r_type == BFD_RELOC_V850_LONGJUMP)
2497 || fixP->fx_r_type == BFD_RELOC_V850_ALIGN
2498 || fixP->fx_r_type == BFD_RELOC_V850_22_PCREL
2499 || fixP->fx_r_type == BFD_RELOC_V850_9_PCREL
2500 || fixP->fx_r_type >= BFD_RELOC_UNUSED))