* config/tc-v850.c: New file.

* config/tc-v850.h: New file.
* configure (v850-*-elf): New target.
* configure.in (v850-*-elf): New target.

1 files changed, 643 insertions, 0 deletions

diff --git a/gas/config/tc-v850.c b/gas/config/tc-v850.c
new file mode 100644
index 0000000..49dd76a
--- /dev/null
+++ b/gas/config/tc-v850.c
@@ -0,0 +1,643 @@
+/* tc-v850.c -- Assembler code for the NEC V850
+
+   Copyright (C) 1996 Free Software Foundation.
+
+   This file is part of GAS, the GNU Assembler.
+
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include <stdio.h>
+#include <ctype.h>
+#include "as.h"
+#include "subsegs.h"     
+#include "opcode/v850.h"
+
+/* Generic assembler global variables which must be defined by all targets. */
+
+/* Characters which always start a comment. */
+const char comment_chars[] = "#";
+
+/* Characters which start a comment at the beginning of a line.  */
+const char line_comment_chars[] = "#";
+
+/* Characters which may be used to separate multiple commands on a 
+   single line.  */
+const char line_separator_chars[] = ";";
+
+/* Characters which are used to indicate an exponent in a floating 
+   point number.  */
+const char EXP_CHARS[] = "eE";
+
+/* Characters which mean that a number is a floating point constant, 
+   as in 0d1.0.  */
+const char FLT_CHARS[] = "dD";
+
+/* local functions */
+static unsigned long v850_insert_operand
+  PARAMS ((unsigned long insn, const struct v850_operand *operand,
+	   offsetT val, char *file, unsigned int line));
+static int reg_name_search PARAMS ((char *name));
+static boolean register_name PARAMS ((expressionS *expressionP));
+static int postfix PARAMS ((char *p));
+static bfd_reloc_code_real_type get_reloc PARAMS ((struct v850_operand *op));
+static unsigned long build_insn PARAMS ((struct v850_opcode *opcode, expressionS *opers));
+
+
+/* fixups */
+#define MAX_INSN_FIXUPS (5)
+struct v850_fixup
+{
+  expressionS exp;
+  int opindex;
+  bfd_reloc_code_real_type reloc;
+};
+struct v850_fixup fixups[MAX_INSN_FIXUPS];
+static int fc;
+
+const char *md_shortopts = "";
+struct option md_longopts[] = {
+  {NULL, no_argument, NULL, 0}
+};
+size_t md_longopts_size = sizeof(md_longopts); 
+
+/* The target specific pseudo-ops which we support.  */
+const pseudo_typeS md_pseudo_table[] =
+{
+  /*
+  { "byte",     ppc_byte,       0 },
+  { "long",     ppc_elf_cons,   4 },
+  { "word",     ppc_elf_cons,   2 },
+  { "short",    ppc_elf_cons,   2 },
+  { "rdata",    ppc_elf_rdata,  0 },
+  { "rodata",   ppc_elf_rdata,  0 },
+  { "lcomm",    ppc_elf_lcomm,  0 },
+  */
+  { NULL,       NULL,           0 }
+};
+
+/* Opcode hash table.  */
+static struct hash_control *v850_hash;
+
+/* Structure to hold information about predefined registers.  */
+struct pd_reg
+{
+  char *name;
+  int value;
+};
+
+
+/* an expressionS only has one register type, so we fake it */
+/* by setting high bits to indicate type */
+#define REGISTER_MASK		0xFF
+
+/*   The table is sorted. Suitable for searching by a binary search. */
+static const struct pd_reg pre_defined_registers[] =
+{
+  { "ep", 30 },			/* ep - element ptr */
+  { "gp", 4 },			/* gp - global ptr */
+  { "lp", 31 },			/* lp - link ptr */
+  { "r0", 0 },
+  { "r1", 1 },
+  { "r10", 10 },
+  { "r11", 11 },
+  { "r12", 12 },
+  { "r13", 13 },
+  { "r14", 14 },
+  { "r15", 15 },
+  { "r16", 16 },
+  { "r17", 17 },
+  { "r18", 18 },
+  { "r19", 19 },
+  { "r2", 2 },
+  { "r20", 20 },
+  { "r21", 21 },
+  { "r22", 22 },
+  { "r23", 23 },
+  { "r24", 24 },
+  { "r25", 25 },
+  { "r26", 26 },
+  { "r27", 27 },
+  { "r28", 28 },
+  { "r29", 29 },
+  { "r3", 3 },
+  { "r30", 30 },
+  { "r31", 31 },
+  { "r4", 4 },
+  { "r5", 5 },
+  { "r6", 6 },
+  { "r7", 7 },
+  { "r8", 8 },
+  { "r9", 9 },
+  { "sp", 3 },			/* sp - stack ptr */
+  { "tp", 5 },			/* tp - text ptr */
+  { "zero", 0 },
+};
+#define REG_NAME_CNT	(sizeof(pre_defined_registers) / sizeof(struct pd_reg))
+
+/* reg_name_search does a binary search of the pre_defined_registers
+   array to see if "name" is a valid regiter name.  Returns the register
+   number from the array on success, or -1 on failure. */
+
+static int
+reg_name_search (name)
+     char *name;
+{
+  int middle, low, high;
+  int cmp;
+
+  low = 0;
+  high = REG_NAME_CNT - 1;
+
+  do
+    {
+      middle = (low + high) / 2;
+      cmp = strcasecmp (name, pre_defined_registers[middle].name);
+      if (cmp < 0)
+	high = middle - 1;
+      else if (cmp > 0)
+	low = middle + 1;
+      else 
+	  return pre_defined_registers[middle].value;
+    }
+  while (low <= high);
+  return -1;
+}
+
+
+/* Summary of register_name().
+ *
+ * in: Input_line_pointer points to 1st char of operand.
+ *
+ * out: A expressionS.
+ *	The operand may have been a register: in this case, X_op == O_register,
+ *	X_add_number is set to the register number, and truth is returned.
+ *	Input_line_pointer->(next non-blank) char after operand, or is in
+ *	its original state.
+ */
+static boolean
+register_name (expressionP)
+     expressionS *expressionP;
+{
+  int reg_number;
+  char *name;
+  char *start;
+  char c;
+
+  /* Find the spelling of the operand */
+  start = name = input_line_pointer;
+
+  c = get_symbol_end ();
+  reg_number = reg_name_search (name);
+
+  /* look to see if it's in the register table */
+  if (reg_number >= 0) 
+    {
+      expressionP->X_op = O_register;
+      expressionP->X_add_number = reg_number;
+
+      /* make the rest nice */
+      expressionP->X_add_symbol = NULL;
+      expressionP->X_op_symbol = NULL;
+      *input_line_pointer = c;	/* put back the delimiting char */
+      return true;
+    }
+  else
+    {
+      /* reset the line as if we had not done anything */
+      *input_line_pointer = c;   /* put back the delimiting char */
+      input_line_pointer = start; /* reset input_line pointer */
+      return false;
+    }
+}
+
+void
+md_show_usage (stream)
+  FILE *stream;
+{
+  fprintf(stream, "V850 options:\n\
+none yet\n");
+} 
+
+int
+md_parse_option (c, arg)
+     int c;
+     char *arg;
+{
+  return 0;
+}
+
+symbolS *
+md_undefined_symbol (name)
+  char *name;
+{
+  return 0;
+}
+
+char *
+md_atof (type, litp, sizep)
+  int type;
+  char *litp;
+  int *sizep;
+{
+  int prec;
+  LITTLENUM_TYPE words[4];
+  char *t;
+  int i;
+
+  switch (type)
+    {
+    case 'f':
+      prec = 2;
+      break;
+
+    case 'd':
+      prec = 4;
+      break;
+
+    default:
+      *sizep = 0;
+      return "bad call to md_atof";
+    }
+  
+  t = atof_ieee (input_line_pointer, type, words);
+  if (t)
+    input_line_pointer = t;
+
+  *sizep = prec * 2;
+
+  for (i = prec - 1; i >= 0; i--)
+    {
+      md_number_to_chars (litp, (valueT) words[i], 2);
+      litp += 2;
+    }
+
+  return NULL;
+}
+
+
+void
+md_convert_frag (abfd, sec, fragP)
+  bfd *abfd;
+  asection *sec;
+  fragS *fragP;
+{
+  /* printf ("call to md_convert_frag \n"); */
+  abort ();
+}
+
+valueT
+md_section_align (seg, addr)
+     asection *seg;
+     valueT addr;
+{
+  int align = bfd_get_section_alignment (stdoutput, seg);
+  return ((addr + (1 << align) - 1) & (-1 << align));
+}
+
+void
+md_begin ()
+{
+  char *prev_name = "";
+  register const struct v850_opcode *op;
+  const struct v850_opcode *op_end;
+
+  v850_hash = hash_new();
+
+  /* Insert unique names into hash table.  The V850 instruction set
+     has many identical opcode names that have different opcodes based
+     on the operands.  This hash table then provides a quick index to
+     the first opcode with a particular name in the opcode table.  */
+
+  op     = v850_opcodes;
+  op_end = v850_opcodes + v850_num_opcodes;
+
+  for (; op < op_end; op++)
+    {
+      if (strcmp (prev_name, op->name)) 
+	{
+	  prev_name = (char *) op->name;
+	  hash_insert (v850_hash, op->name, (char *) op);
+	}
+    }
+}
+
+
+static bfd_reloc_code_real_type 
+get_reloc (op) 
+     struct v850_operand *op;
+{
+  abort ();
+}
+
+
+/* get_operands parses a string of operands and returns and array of
+   expressions. */
+static int
+get_operands (exp)
+     expressionS exp[];
+{
+  char *p = input_line_pointer;
+  int numops = 0;
+  
+  while (*p) 
+    {
+      while (*p == ' ' || *p == '\t' || *p == ',')
+        p++;
+      if (*p==0 || *p=='\n' || *p=='\r')
+        break;
+
+      input_line_pointer = p;
+
+      if (!register_name(&exp[numops]))
+	expression(&exp[numops]);
+
+      numops++;
+      p = input_line_pointer;
+    }
+
+  exp[numops].X_op = 0;
+  return (numops);
+}
+
+
+
+void
+md_assemble (str) 
+     char *str;
+{
+  char *s;
+  struct v850_opcode *opcode;
+  struct v850_opcode *next_opcode;
+  const unsigned char *opindex_ptr;
+  int next_opindex;
+  unsigned long insn;
+  char *f;
+  int i;
+  int numops;
+  int match;
+
+  int numopts;
+  expressionS myops[5];
+
+  /* Get the opcode.  */
+  for (s = str; *s != '\0' && ! isspace (*s); s++)
+    ;
+  if (*s != '\0')
+    *s++ = '\0';
+
+  /* find the first opcode with the proper name */
+  opcode = (struct v850_opcode *)hash_find (v850_hash, str);
+  if (opcode == NULL)
+    {
+      as_bad ("Unrecognized opcode: `%s'", str);
+      return;
+    }
+
+  str = s;
+  while (isspace (*str))
+    ++str;
+
+  input_line_pointer = str;
+
+  /* get all the operands and save them as expressions */
+  numops = get_operands (myops);
+
+  /* now search the opcode table for one with operands that matches
+     what we've got */
+  match = 0;
+  while (!match) 
+    {
+      match = 1;
+      for (i = 0; opcode->operands[i]; i++)
+	{
+	  int flags = v850_operands[opcode->operands[i]].flags;
+	  int X_op = myops[i].X_op;
+	  int num  = myops[i].X_add_number;
+
+	  if (X_op == 0)
+	    {
+	      match = 0;
+	      break;
+	    }
+
+	  if (flags & OPERAND_REG) 
+	    {
+	      if (X_op != O_register) 
+		{
+		  match = 0;
+		  break;
+		}
+	    }
+	}
+
+      /* we're only done if the operands matched so far AND there are
+	 no more to check. */
+      if (match && myops[i].X_op == 0)
+	break;
+      
+      next_opcode = opcode + 1;
+      if (next_opcode->opcode == 0)
+	break;
+      if (strcmp (next_opcode->name, opcode->name))
+	break;
+      opcode = next_opcode;
+    }
+
+  if (!match) 
+    {
+      as_bad ("Unrecognized operands");
+      return;
+    }
+
+  insn = opcode->opcode;
+
+#if 0
+  while (isspace (*str))
+    ++str;
+
+  if (*str != '\0')
+    as_bad ("junk at end of line: `%s'", str);
+#endif
+
+  /* Write out the instruction.  */
+  f = frag_more (2);
+  md_number_to_chars (f, insn, 2);
+}
+
+
+/* if while processing a fixup, a reloc really needs to be created */
+/* then it is done here */
+                 
+arelent *
+tc_gen_reloc (seg, fixp)
+     asection *seg;
+     fixS *fixp;
+{
+  arelent *reloc;
+  reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent));
+  reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
+  reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
+  reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
+  if (reloc->howto == (reloc_howto_type *) NULL)
+    {
+      as_bad_where (fixp->fx_file, fixp->fx_line,
+                    "reloc %d not supported by object file format", (int)fixp->fx_r_type);
+      return NULL;
+    }
+  reloc->addend = fixp->fx_addnumber;
+  /*  printf("tc_gen_reloc: addr=%x  addend=%x\n", reloc->address, reloc->addend); */
+  return reloc;
+}
+
+int
+md_estimate_size_before_relax (fragp, seg)
+     fragS *fragp;
+     asection *seg;
+{
+  abort ();
+  return 0;
+} 
+
+long
+md_pcrel_from_section (fixp, sec)
+     fixS *fixp;
+     segT sec;
+{
+    return 0;
+    /*  return fixp->fx_frag->fr_address + fixp->fx_where; */
+}
+
+int
+md_apply_fix3 (fixp, valuep, seg)
+     fixS *fixp;
+     valueT *valuep;
+     segT seg;
+{
+  abort();
+#if 0
+  valueT value;
+  char *where;
+  unsigned long insn;
+  int op_type;
+
+  if (fixp->fx_addsy == (symbolS *) NULL)
+    {
+      value = *valuep;
+      fixp->fx_done = 1;
+    }
+  else if (fixp->fx_pcrel)
+    value = *valuep;
+  else
+    {
+      value = fixp->fx_offset;
+      if (fixp->fx_subsy != (symbolS *) NULL)
+	{
+	  if (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
+	    value -= S_GET_VALUE (fixp->fx_subsy);
+	  else
+	    {
+	      /* We don't actually support subtracting a symbol.  */
+	      as_bad_where (fixp->fx_file, fixp->fx_line,
+			    "expression too complex");
+	    }
+	}
+    }
+  
+  /*   printf("md_apply_fix: value=0x%x  type=%d\n",  value, fixp->fx_r_type); */
+
+  op_type = fixp->fx_r_type;
+  fixp->fx_r_type = get_reloc((struct v850_operand *)&v850_operands[op_type]); 
+
+  /*  printf("reloc=%d\n",fixp->fx_r_type); */
+
+  /* Fetch the instruction, insert the fully resolved operand
+     value, and stuff the instruction back again.  */
+  where = fixp->fx_frag->fr_literal + fixp->fx_where;
+  insn = bfd_getb32 ((unsigned char *) where);
+  /* printf("   insn=%x  value=%x\n",insn,value); */
+
+  insn = v850_insert_operand (insn, op_type, (offsetT) value);
+  
+  /* printf("   new insn=%x\n",insn); */
+  
+  bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
+  
+  if (fixp->fx_done)
+    return 1;
+
+  fixp->fx_addnumber = value;
+  return 1;
+#endif
+}
+
+
+/* Insert an operand value into an instruction.  */
+
+static unsigned long
+v850_insert_operand (insn, operand, val, file, line)
+     unsigned long insn;
+     const struct v850_operand *operand;
+     offsetT val;
+     char *file;
+     unsigned int line;
+{
+  if (operand->bits != 32)
+    {
+      long min, max;
+      offsetT test;
+
+#if 0
+      if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
+        {
+          if ((operand->flags & PPC_OPERAND_SIGNOPT) != 0
+              && ppc_size == PPC_OPCODE_32)
+            max = (1 << operand->bits) - 1;
+          else
+            max = (1 << (operand->bits - 1)) - 1;
+          min = - (1 << (operand->bits - 1));
+        }
+      else
+#endif
+        {
+          max = (1 << operand->bits) - 1;
+          min = 0;
+        }
+
+#if 0
+      if ((operand->flags & PPC_OPERAND_NEGATIVE) != 0)
+        test = - val;
+      else
+#endif
+        test = val;
+
+
+      if (test < (offsetT) min || test > (offsetT) max)
+        {
+          const char *err =
+            "operand out of range (%s not between %ld and %ld)";
+          char buf[100];
+
+          sprint_value (buf, test);
+          if (file == (char *) NULL)
+            as_warn (err, buf, min, max);
+          else
+            as_warn_where (file, line, err, buf, min, max);
+        }
+    }
+
+  insn |= (((long) val & ((1 << operand->bits) - 1)) << operand->shift);
+  return insn;
+}