1 /* tc-v850.c -- Assembler code for the NEC V850
3 Copyright (C) 1996 Free Software Foundation.
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. */
26 #include "opcode/v850.h"
28 /* Structure to hold information about predefined registers. */
35 /* Generic assembler global variables which must be defined by all targets. */
37 /* Characters which always start a comment. */
38 const char comment_chars[] = "#";
40 /* Characters which start a comment at the beginning of a line. */
41 const char line_comment_chars[] = ";#";
43 /* Characters which may be used to separate multiple commands on a
45 const char line_separator_chars[] = ";";
47 /* Characters which are used to indicate an exponent in a floating
49 const char EXP_CHARS[] = "eE";
51 /* Characters which mean that a number is a floating point constant,
53 const char FLT_CHARS[] = "dD";
57 static unsigned long v850_insert_operand
58 PARAMS ((unsigned long insn, const struct v850_operand *operand,
59 offsetT val, char *file, unsigned int line));
60 static int reg_name_search PARAMS ((const struct reg_name *, int, const char *));
61 static boolean register_name PARAMS ((expressionS *expressionP));
62 static boolean system_register_name PARAMS ((expressionS *expressionP));
63 static boolean cc_name PARAMS ((expressionS *expressionP));
64 static bfd_reloc_code_real_type v850_reloc_prefix PARAMS ((void));
68 #define MAX_INSN_FIXUPS (5)
73 bfd_reloc_code_real_type reloc;
75 struct v850_fixup fixups[MAX_INSN_FIXUPS];
78 const char *md_shortopts = "";
79 struct option md_longopts[] = {
80 {NULL, no_argument, NULL, 0}
82 size_t md_longopts_size = sizeof(md_longopts);
84 /* The target specific pseudo-ops which we support. */
85 const pseudo_typeS md_pseudo_table[] =
90 /* Opcode hash table. */
91 static struct hash_control *v850_hash;
93 /* This table is sorted. Suitable for searching by a binary search. */
94 static const struct reg_name pre_defined_registers[] =
96 { "ep", 30 }, /* ep - element ptr */
97 { "gp", 4 }, /* gp - global ptr */
98 { "lp", 31 }, /* lp - link ptr */
131 { "sp", 3 }, /* sp - stack ptr */
132 { "tp", 5 }, /* tp - text ptr */
135 #define REG_NAME_CNT (sizeof(pre_defined_registers) / sizeof(struct reg_name))
138 static const struct reg_name system_registers[] =
147 #define SYSREG_NAME_CNT (sizeof(system_registers) / sizeof(struct reg_name))
149 static const struct reg_name cc_names[] =
172 #define CC_NAME_CNT (sizeof(cc_names) / sizeof(struct reg_name))
174 /* reg_name_search does a binary search of the given register table
175 to see if "name" is a valid regiter name. Returns the register
176 number from the array on success, or -1 on failure. */
179 reg_name_search (regs, regcount, name)
180 const struct reg_name *regs;
184 int middle, low, high;
192 middle = (low + high) / 2;
193 cmp = strcasecmp (name, regs[middle].name);
199 return regs[middle].value;
206 /* Summary of register_name().
208 * in: Input_line_pointer points to 1st char of operand.
210 * out: A expressionS.
211 * The operand may have been a register: in this case, X_op == O_register,
212 * X_add_number is set to the register number, and truth is returned.
213 * Input_line_pointer->(next non-blank) char after operand, or is in
214 * its original state.
217 register_name (expressionP)
218 expressionS *expressionP;
225 /* Find the spelling of the operand */
226 start = name = input_line_pointer;
228 c = get_symbol_end ();
229 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
231 /* look to see if it's in the register table */
234 expressionP->X_op = O_register;
235 expressionP->X_add_number = reg_number;
237 /* make the rest nice */
238 expressionP->X_add_symbol = NULL;
239 expressionP->X_op_symbol = NULL;
240 *input_line_pointer = c; /* put back the delimiting char */
245 /* reset the line as if we had not done anything */
246 *input_line_pointer = c; /* put back the delimiting char */
247 input_line_pointer = start; /* reset input_line pointer */
252 /* Summary of system_register_name().
254 * in: Input_line_pointer points to 1st char of operand.
256 * out: A expressionS.
257 * The operand may have been a register: in this case, X_op == O_register,
258 * X_add_number is set to the register number, and truth is returned.
259 * Input_line_pointer->(next non-blank) char after operand, or is in
260 * its original state.
263 system_register_name (expressionP)
264 expressionS *expressionP;
271 /* Find the spelling of the operand */
272 start = name = input_line_pointer;
274 c = get_symbol_end ();
275 reg_number = reg_name_search (system_registers, SYSREG_NAME_CNT, name);
277 /* look to see if it's in the register table */
280 expressionP->X_op = O_register;
281 expressionP->X_add_number = reg_number;
283 /* make the rest nice */
284 expressionP->X_add_symbol = NULL;
285 expressionP->X_op_symbol = NULL;
286 *input_line_pointer = c; /* put back the delimiting char */
291 /* reset the line as if we had not done anything */
292 *input_line_pointer = c; /* put back the delimiting char */
293 input_line_pointer = start; /* reset input_line pointer */
298 /* Summary of cc_name().
300 * in: Input_line_pointer points to 1st char of operand.
302 * out: A expressionS.
303 * The operand may have been a register: in this case, X_op == O_register,
304 * X_add_number is set to the register number, and truth is returned.
305 * Input_line_pointer->(next non-blank) char after operand, or is in
306 * its original state.
309 cc_name (expressionP)
310 expressionS *expressionP;
317 /* Find the spelling of the operand */
318 start = name = input_line_pointer;
320 c = get_symbol_end ();
321 reg_number = reg_name_search (cc_names, CC_NAME_CNT, name);
323 /* look to see if it's in the register table */
326 expressionP->X_op = O_constant;
327 expressionP->X_add_number = reg_number;
329 /* make the rest nice */
330 expressionP->X_add_symbol = NULL;
331 expressionP->X_op_symbol = NULL;
332 *input_line_pointer = c; /* put back the delimiting char */
337 /* reset the line as if we had not done anything */
338 *input_line_pointer = c; /* put back the delimiting char */
339 input_line_pointer = start; /* reset input_line pointer */
345 md_show_usage (stream)
348 fprintf(stream, "V850 options:\n\
353 md_parse_option (c, arg)
361 md_undefined_symbol (name)
368 md_atof (type, litp, sizep)
374 LITTLENUM_TYPE words[4];
390 return "bad call to md_atof";
393 t = atof_ieee (input_line_pointer, type, words);
395 input_line_pointer = t;
399 for (i = prec - 1; i >= 0; i--)
401 md_number_to_chars (litp, (valueT) words[i], 2);
410 md_convert_frag (abfd, sec, fragP)
415 /* printf ("call to md_convert_frag \n"); */
420 md_section_align (seg, addr)
424 int align = bfd_get_section_alignment (stdoutput, seg);
425 return ((addr + (1 << align) - 1) & (-1 << align));
431 char *prev_name = "";
432 register const struct v850_opcode *op;
434 v850_hash = hash_new();
436 /* Insert unique names into hash table. The V850 instruction set
437 has many identical opcode names that have different opcodes based
438 on the operands. This hash table then provides a quick index to
439 the first opcode with a particular name in the opcode table. */
444 if (strcmp (prev_name, op->name))
446 prev_name = (char *) op->name;
447 hash_insert (v850_hash, op->name, (char *) op);
453 static bfd_reloc_code_real_type
456 if (strncmp(input_line_pointer, "hi0(", 4) == 0)
458 input_line_pointer += 4;
459 return BFD_RELOC_HI16;
461 if (strncmp(input_line_pointer, "hi(", 3) == 0)
463 input_line_pointer += 3;
464 return BFD_RELOC_HI16_S;
466 if (strncmp (input_line_pointer, "lo(", 3) == 0)
468 input_line_pointer += 3;
469 return BFD_RELOC_LO16;
472 /* FIXME: implement sda, tda, zda here */
474 return BFD_RELOC_UNUSED;
482 struct v850_opcode *opcode;
483 struct v850_opcode *next_opcode;
484 const unsigned char *opindex_ptr;
486 unsigned long insn, size;
490 bfd_reloc_code_real_type reloc;
492 /* Get the opcode. */
493 for (s = str; *s != '\0' && ! isspace (*s); s++)
498 /* find the first opcode with the proper name */
499 opcode = (struct v850_opcode *)hash_find (v850_hash, str);
502 as_bad ("Unrecognized opcode: `%s'", str);
507 while (isspace (*str))
510 input_line_pointer = str;
514 const char *errmsg = NULL;
519 insn = opcode->opcode;
520 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
522 const struct v850_operand *operand;
526 if (next_opindex == 0)
528 operand = &v850_operands[*opindex_ptr];
532 operand = &v850_operands[next_opindex];
538 while (*str == ' ' || *str == ',' || *str == '[' || *str == ']')
541 /* Gather the operand. */
542 hold = input_line_pointer;
543 input_line_pointer = str;
546 /* lo(), hi(), hi0(), etc... */
547 if ((reloc = v850_reloc_prefix()) != BFD_RELOC_UNUSED)
551 if (*input_line_pointer++ != ')')
553 errmsg = "syntax error: expected `)'";
557 if (ex.X_op == O_constant)
562 ex.X_add_number &= 0xffff;
566 ex.X_add_number = ((ex.X_add_number >> 16) & 0xffff);
569 case BFD_RELOC_HI16_S:
570 ex.X_add_number = ((ex.X_add_number >> 16) & 0xffff)
571 + ((ex.X_add_number >> 15) & 1);
578 insn = v850_insert_operand (insn, operand, ex.X_add_number,
583 if (fc > MAX_INSN_FIXUPS)
584 as_fatal ("too many fixups");
587 fixups[fc].opindex = *opindex_ptr;
588 fixups[fc].reloc = reloc;
594 if ((operand->flags & V850_OPERAND_REG) != 0)
596 if (!register_name(&ex))
598 errmsg = "invalid register name";
602 else if ((operand->flags & V850_OPERAND_SRG) != 0)
604 if (!system_register_name(&ex))
606 errmsg = "invalid system register name";
610 else if ((operand->flags & V850_OPERAND_EP) != 0)
612 char *start = input_line_pointer;
613 char c = get_symbol_end ();
614 if (strcmp (start, "ep") != 0 && strcmp (start, "r30") != 0)
616 /* Put things back the way we found them. */
617 *input_line_pointer = c;
618 input_line_pointer = start;
619 errmsg = "expected EP register";
622 *input_line_pointer = c;
623 str = input_line_pointer;
624 input_line_pointer = hold;
626 while (*str == ' ' || *str == ',' || *str == '[' || *str == ']')
630 else if ((operand->flags & V850_OPERAND_CC) != 0)
634 errmsg = "invalid condition code name";
638 else if (register_name (&ex)
639 && (operand->flags & V850_OPERAND_REG) == 0)
641 errmsg = "syntax error: register not expected";
644 else if (system_register_name (&ex)
645 && (operand->flags & V850_OPERAND_SRG) == 0)
647 errmsg = "syntax error: system register not expected";
650 else if (cc_name (&ex)
651 && (operand->flags & V850_OPERAND_CC) == 0)
653 errmsg = "syntax error: condition code not expected";
664 errmsg = "illegal operand";
667 errmsg = "missing operand";
670 if ((operand->flags & (V850_OPERAND_REG | V850_OPERAND_SRG)) == 0)
672 errmsg = "invalid operand";
676 insn = v850_insert_operand (insn, operand, ex.X_add_number,
681 insn = v850_insert_operand (insn, operand, ex.X_add_number,
686 /* We need to generate a fixup for this expression. */
687 if (fc >= MAX_INSN_FIXUPS)
688 as_fatal ("too many fixups");
690 fixups[fc].opindex = *opindex_ptr;
691 fixups[fc].reloc = BFD_RELOC_UNUSED;
698 str = input_line_pointer;
699 input_line_pointer = hold;
701 while (*str == ' ' || *str == ',' || *str == '[' || *str == ']')
709 next_opcode = opcode + 1;
710 if (next_opcode->opcode != 0 && !strcmp(next_opcode->name, opcode->name))
712 opcode = next_opcode;
716 as_bad ("%s", errmsg);
722 while (isspace (*str))
726 as_bad ("junk at end of line: `%s'", str);
728 input_line_pointer = str;
730 /* Write out the instruction.
732 Four byte insns have an opcode with the two high bits on. */
733 if ((insn & 0x0600) == 0x0600)
737 f = frag_more (size);
738 md_number_to_chars (f, insn, size);
740 /* Create any fixups. At this point we do not use a
741 bfd_reloc_code_real_type, but instead just use the
742 BFD_RELOC_UNUSED plus the operand index. This lets us easily
743 handle fixups for any operand type, although that is admittedly
744 not a very exciting feature. We pick a BFD reloc type in
746 for (i = 0; i < fc; i++)
748 const struct v850_operand *operand;
750 operand = &v850_operands[fixups[i].opindex];
751 if (fixups[i].reloc != BFD_RELOC_UNUSED)
753 reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
761 size = bfd_get_reloc_size (reloc_howto);
764 if (size < 1 || size > 4)
767 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset, size,
769 reloc_howto->pc_relative,
774 fix_new_exp (frag_now, f - frag_now->fr_literal, 4,
776 1 /* FIXME: V850_OPERAND_RELATIVE ??? */,
777 ((bfd_reloc_code_real_type)
778 (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
784 /* if while processing a fixup, a reloc really needs to be created */
785 /* then it is done here */
788 tc_gen_reloc (seg, fixp)
793 reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent));
794 reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
795 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
796 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
797 if (reloc->howto == (reloc_howto_type *) NULL)
799 as_bad_where (fixp->fx_file, fixp->fx_line,
800 "reloc %d not supported by object file format", (int)fixp->fx_r_type);
803 reloc->addend = fixp->fx_addnumber;
804 /* printf("tc_gen_reloc: addr=%x addend=%x\n", reloc->address, reloc->addend); */
809 md_estimate_size_before_relax (fragp, seg)
820 /* If the symbol is undefined, or in a section other than our own,
821 then let the linker figure it out. */
822 if (fixp->fx_addsy != (symbolS *) NULL && ! S_IS_DEFINED (fixp->fx_addsy))
824 /* The symbol is undefined. Let the linker figure it out. */
827 return fixp->fx_frag->fr_address + fixp->fx_where;
831 md_apply_fix3 (fixp, valuep, seg)
839 if (fixp->fx_addsy == (symbolS *) NULL)
844 else if (fixp->fx_pcrel)
848 value = fixp->fx_offset;
849 if (fixp->fx_subsy != (symbolS *) NULL)
851 if (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
852 value -= S_GET_VALUE (fixp->fx_subsy);
855 /* We don't actually support subtracting a symbol. */
856 as_bad_where (fixp->fx_file, fixp->fx_line,
857 "expression too complex");
862 /* printf("md_apply_fix: value=0x%x type=%d\n", value, fixp->fx_r_type); */
864 if ((int) fixp->fx_r_type >= (int) BFD_RELOC_UNUSED)
867 const struct v850_operand *operand;
871 opindex = (int) fixp->fx_r_type - (int) BFD_RELOC_UNUSED;
872 operand = &v850_operands[opindex];
874 /* Fetch the instruction, insert the fully resolved operand
875 value, and stuff the instruction back again.
877 Note the instruction has been stored in little endian
879 where = fixp->fx_frag->fr_literal + fixp->fx_where;
881 insn = bfd_getl32((unsigned char *) where);
882 insn = v850_insert_operand (insn, operand, (offsetT) value,
883 fixp->fx_file, fixp->fx_line);
884 bfd_putl32((bfd_vma) insn, (unsigned char *) where);
888 /* Nothing else to do here. */
892 /* Determine a BFD reloc value based on the operand information.
893 We are only prepared to turn a few of the operands into relocs. */
895 if (operand->bits == 22)
896 fixp->fx_r_type = BFD_RELOC_V850_22_PCREL;
897 else if (operand->bits == 9)
898 fixp->fx_r_type = BFD_RELOC_V850_9_PCREL;
901 as_bad_where(fixp->fx_file, fixp->fx_line,
902 "unresolved expression that must be resolved");
907 else if (fixp->fx_done)
909 /* We still have to insert the value into memory! */
910 where = fixp->fx_frag->fr_literal + fixp->fx_where;
911 if (fixp->fx_size == 1)
912 *where = value & 0xff;
913 if (fixp->fx_size == 2)
914 bfd_putl16(value & 0xffff, (unsigned char *) where);
915 if (fixp->fx_size == 4)
916 bfd_putl32(value, (unsigned char *) where);
919 fixp->fx_addnumber = value;
924 /* Insert an operand value into an instruction. */
927 v850_insert_operand (insn, operand, val, file, line)
929 const struct v850_operand *operand;
934 if (operand->bits != 16)
939 if ((operand->flags & V850_OPERAND_SIGNED) != 0)
941 max = (1 << (operand->bits - 1)) - 1;
942 min = - (1 << (operand->bits - 1));
946 max = (1 << operand->bits) - 1;
953 if (test < (offsetT) min || test > (offsetT) max)
956 "operand out of range (%s not between %ld and %ld)";
959 sprint_value (buf, test);
960 if (file == (char *) NULL)
961 as_warn (err, buf, min, max);
963 as_warn_where (file, line, err, buf, min, max);
969 const char *message = NULL;
970 insn = (*operand->insert) (insn, val, &message);
973 if (file == (char *) NULL)
976 as_warn_where (file, line, message);
980 insn |= (((long) val & ((1 << operand->bits) - 1)) << operand->shift);