Subversion Repositories scarts

/* tc-scarts_32.c -- Assembler for the SCARTS_32 family.

   Copyright 2001, 2002, 2003, 2005, 2006, 2007 Free Software Foundation.

   Contributed by Martin Walter <mwalter@opencores.org>

   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 3, 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, 51 Franklin Street - Fifth Floor,

   Boston, MA 02110-1301, USA.  */

#include "as.h"

#include "subsegs.h"

#include "symcat.h"

#include "opcodes/scarts_32-desc.h"

#include "opcodes/scarts_32-opc.h"

#include "cgen.h"

#include "libbfd.h"

const char comment_chars[]        = ";";

const char line_comment_chars[]   = "#";

const char line_separator_chars[] = "|";

const char EXP_CHARS[]            = "eE";

const char FLT_CHARS[]            = "dD";

const char scarts_32_comment_chars[] = ";#";

/* Target specific short options. */

#define SCARTS_32_SHORTOPTS ""

const char *md_shortopts = SCARTS_32_SHORTOPTS;

/* Target specific long options. */

struct option md_longopts[] =

{

  {NULL, no_argument, NULL, 0}

};

size_t md_longopts_size = sizeof(md_longopts);

/* Set the default machine. */

#define DEFAULT_MACHINE bfd_mach_scarts_32

unsigned long scarts_32_mach = DEFAULT_MACHINE;

/* Target specific pseudo-ops. */

const pseudo_typeS md_pseudo_table[] =

{

  {NULL,  NULL, 0}

};

/* GAS will call md_parse_option whenever getopt returns an unrecognized code,

   presumably indicating a special code value which appears in md_longopts.

   This function should return non-zero if it handled the option and zero

   otherwise. There is no need to print a message about an option not being

   recognized. This will be handled by the generic code. */

int

md_parse_option(int c ATTRIBUTE_UNUSED, char *arg ATTRIBUTE_UNUSED)

{

  return 0;

}

/* GAS will call md_show_usage when a usage message is printed; it should print

   a description of the machine specific options. */

void

md_show_usage(FILE * stream ATTRIBUTE_UNUSED)

{

}

/* GAS will call this function at the start of the assembly, after the command

   line arguments have been parsed and all the machine independent

   initializations have been completed. */

void

md_begin(void)

{

  /* Set the machine number and endianness.  */

  gas_cgen_cpu_desc = scarts_32_cgen_cpu_open(CGEN_CPU_OPEN_MACHS, scarts_32_mach, CGEN_CPU_OPEN_ENDIAN, (target_big_endian ? CGEN_ENDIAN_BIG : CGEN_ENDIAN_LITTLE), CGEN_CPU_OPEN_END);

  scarts_32_cgen_init_asm(gas_cgen_cpu_desc);

  /* This is a callback from cgen to gas to parse operands.  */

  cgen_set_parse_operand_fn(gas_cgen_cpu_desc, gas_cgen_parse_operand);

  /* Set the machine type.  */

  bfd_default_set_arch_mach(stdoutput, bfd_arch_scarts_32, scarts_32_mach);

}

/* GAS will call this function for each input line which does not contain a

   pseudoop. The argument is a null terminated string. The function should

   assemble the string as an instruction with operands. */

void

md_assemble(char *str)

{

  const CGEN_INSN *insn;

  char *errmsg;

  CGEN_FIELDS fields;

#if CGEN_INT_INSN_P

  CGEN_INSN_INT buffer[CGEN_MAX_INSN_SIZE / sizeof(CGEN_INSN_INT)];

#else

  unsigned char buffer[CGEN_MAX_INSN_SIZE];

#endif

  gas_cgen_init_parse();

  insn = scarts_32_cgen_assemble_insn(gas_cgen_cpu_desc, str, &fields, buffer, &errmsg);

  if (!insn)

  {

    as_bad(errmsg);

    return;

  }

  /* MWA: Instead of the instruction size, CGEN_FIELDS_BITSIZE(&fields)

   * erroneously delivers the value of the instruction and is therefore

   * replaced by the the proper CGEN_INSN_BITSIZE(insn). */

  gas_cgen_finish_insn(insn, buffer, CGEN_INSN_BITSIZE(insn), 0, NULL);

}

/* GAS will call this function when a symbol table lookup fails, before it

   creates a new symbol. Typically this would be used to supply symbols whose

   name or value changes dynamically, possibly in a context sensitive way.

   Predefined symbols with fixed values, such as register names or condition

   codes, are typically entered directly into the symbol table when md_begin

   is called. */

symbolS *

md_undefined_symbol(char * name ATTRIBUTE_UNUSED)

{

  return 0;

}

/* GAS will call this function with one argument, an expressionS pointer, for

   any expression that can not be recognized. When the function is called,

   input_line_pointer will point to the start of the expression. */

void

md_operand(expressionS *exp)

{

  if (*input_line_pointer == ';' || *input_line_pointer == '#')

  {

    input_line_pointer++;

    expression(exp);

  }

}

/* This function is called to convert an ASCII string into a floating point

   value in format used by the CPU. It takes three arguments. The first is type

   which is a byte describing the type of floating point number to be created.

   Possible values are ’f’ or ’s’ for single precision, ’d’ or ’r’ for double

   precision and ’x’ or ’p’ for extended precision. Either lower or upper case

   versions of these letters can be used.

   The second parameter is litP which is a pointer to a byte array where the

   converted value should be stored. The third argument is sizeP, which is a

   pointer to a integer that should be filled in with the number of LITTLENUMs

   emitted into the byte array. (LITTLENUM is defined in gas/bignum.h). The

   function should return NULL upon success or an error string upon failure. */

/* Equal to MAX_PRECISION in atof-ieee.c. */

#define MAX_LITTLENUMS 6

char *

md_atof (int type, char *litP, int *sizeP)

{

  char *t;

  int i, prec;

  LITTLENUM_TYPE words[MAX_LITTLENUMS];

  switch (type)

  {

    case 'f':

    case 'F':

    case 's':

    case 'S':

      prec = 2;

      break;

    case 'd':

    case 'D':

    case 'r':

    case 'R':

      prec = 4;

      break;

   /* FIXME: Some targets allow other format chars for bigger sizes here. */

    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 * sizeof(LITTLENUM_TYPE);

  for (i = 0; i < prec; i++)

  {

    md_number_to_chars (litP, (valueT) words[i], sizeof (LITTLENUM_TYPE));

    litP += sizeof (LITTLENUM_TYPE);

  }

  return 0;

}

int

md_estimate_size_before_relax(register fragS *fragP ATTRIBUTE_UNUSED, register segT segment_type ATTRIBUTE_UNUSED)

{

  printf(_("Bad call to md_estimate_size_before_relax\n"));

  abort();

}

void

md_convert_frag(bfd *abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED, fragS *fragP ATTRIBUTE_UNUSED)

{

}

long

md_pcrel_from_section(fixS *fixP, segT sec)

{

  if (fixP->fx_addsy != (symbolS *) NULL && (! S_IS_DEFINED (fixP->fx_addsy) || S_GET_SEGMENT (fixP->fx_addsy) != sec))

    /* The symbol is undefined (or is defined but not in this section).

       Let the linker figure it out. */

    return 0;

  return (fixP->fx_frag->fr_address + fixP->fx_where);

}

valueT

md_section_align(segT segment, valueT size)

{

  int align = bfd_get_section_alignment(stdoutput, segment);

  return ((size + (1 << align) - 1) & (-1 << align));

}

/* GAS will call this for each fixup.

   It should store the correct value in the object file.  */

void

scarts_32_md_apply_fix(fixS *fixP, valueT * valP, segT seg)

{

  long value;

  value = *valP;

  /* It is assumed that the program counter gets incremented after

   * an instruction fetch. In this case, a PC-relative relocation

   * value would need to be adjusted by the incrementation value. */

  /*

  if (fixP->fx_pcrel == 1)

    value -= 2;

  */

  gas_cgen_md_apply_fix(fixP, (valueT *)&value, seg);

}

int

scarts_32_force_relocation (fixP)

  fixS *fixP;

{

  int type;

  type = fixP->fx_r_type < BFD_RELOC_UNUSED ? (int) fixP->fx_r_type : fixP->fx_cgen.opinfo;

  switch (type)

  {

    case BFD_RELOC_SCARTS_32_PCREL_10:

      return 1;

    default:

      break;

  }

  return generic_force_reloc(fixP);

}

/* Return the bfd reloc type for OPERAND of INSN at fixup fixP.

   Returns BFD_RELOC_NONE if no reloc type can be found. */

bfd_reloc_code_real_type

md_cgen_lookup_reloc(const CGEN_INSN *insn ATTRIBUTE_UNUSED, const CGEN_OPERAND *operand, fixS *fixP)

{

  bfd_reloc_code_real_type type;

  type = BFD_RELOC_NONE;

  switch (operand->type)

  {

    case SCARTS_32_OPERAND_SIMM8:

      fixP->fx_pcrel = 0;

      if (fixP->fx_cgen.opinfo != 0)

        type = fixP->fx_cgen.opinfo;

      break;

    case SCARTS_32_OPERAND_UIMM8:

      fixP->fx_pcrel = 0;

      if (fixP->fx_cgen.opinfo != 0)

        type = fixP->fx_cgen.opinfo;

      break;

    case SCARTS_32_OPERAND_SADDR10_PCREL:

      fixP->fx_pcrel = 1;

      type = BFD_RELOC_SCARTS_32_PCREL_10;

      break;

    default:

      break;

  }

  return type;

}