OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [config/] [score/] [score.c] - Diff between revs 38 and 154

Only display areas with differences | Details | Blame | View Log

Rev 38 Rev 154 
/* Output routines for Sunplus S+CORE processor
 
/* Output routines for Sunplus S+CORE processor
 
   Copyright (C) 2005, 2007 Free Software Foundation, Inc.
 
   Copyright (C) 2005, 2007 Free Software Foundation, Inc.
 
   Contributed by Sunnorth.
 
   Contributed by Sunnorth.
 
 
 
 
 
   This file is part of GCC.
 
   This file is part of GCC.
 
 
 
 
 
   GCC is free software; you can redistribute it and/or modify it
 
   GCC is free software; you can redistribute it and/or modify it
 
   under the terms of the GNU General Public License as published
 
   under the terms of the GNU General Public License as published
 
   by the Free Software Foundation; either version 3, or (at your
 
   by the Free Software Foundation; either version 3, or (at your
 
   option) any later version.
 
   option) any later version.
 
 
 
 
 
   GCC is distributed in the hope that it will be useful, but WITHOUT
 
   GCC is distributed in the hope that it will be useful, but WITHOUT
 
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
 
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
 
   License for more details.
 
   License for more details.
 
 
 
 
 
   You should have received a copy of the GNU General Public License
 
   You should have received a copy of the GNU General Public License
 
   along with GCC; see the file COPYING3.  If not see
 
   along with GCC; see the file COPYING3.  If not see
 
   <http://www.gnu.org/licenses/>.  */
 
   <http://www.gnu.org/licenses/>.  */
 
 
 
 
 
#include "config.h"
 
#include "config.h"
 
#include "system.h"
 
#include "system.h"
 
#include "coretypes.h"
 
#include "coretypes.h"
 
#include "tm.h"
 
#include "tm.h"
 
#include <signal.h>
 
#include <signal.h>
 
#include "rtl.h"
 
#include "rtl.h"
 
#include "regs.h"
 
#include "regs.h"
 
#include "hard-reg-set.h"
 
#include "hard-reg-set.h"
 
#include "real.h"
 
#include "real.h"
 
#include "insn-config.h"
 
#include "insn-config.h"
 
#include "conditions.h"
 
#include "conditions.h"
 
#include "insn-attr.h"
 
#include "insn-attr.h"
 
#include "recog.h"
 
#include "recog.h"
 
#include "toplev.h"
 
#include "toplev.h"
 
#include "output.h"
 
#include "output.h"
 
#include "tree.h"
 
#include "tree.h"
 
#include "function.h"
 
#include "function.h"
 
#include "expr.h"
 
#include "expr.h"
 
#include "optabs.h"
 
#include "optabs.h"
 
#include "flags.h"
 
#include "flags.h"
 
#include "reload.h"
 
#include "reload.h"
 
#include "tm_p.h"
 
#include "tm_p.h"
 
#include "ggc.h"
 
#include "ggc.h"
 
#include "gstab.h"
 
#include "gstab.h"
 
#include "hashtab.h"
 
#include "hashtab.h"
 
#include "debug.h"
 
#include "debug.h"
 
#include "target.h"
 
#include "target.h"
 
#include "target-def.h"
 
#include "target-def.h"
 
#include "integrate.h"
 
#include "integrate.h"
 
#include "langhooks.h"
 
#include "langhooks.h"
 
#include "cfglayout.h"
 
#include "cfglayout.h"
 
#include "score-mdaux.h"
 
#include "score-mdaux.h"
 
 
 
 
 
#define GR_REG_CLASS_P(C)        ((C) == G16_REGS || (C) == G32_REGS)
 
#define GR_REG_CLASS_P(C)        ((C) == G16_REGS || (C) == G32_REGS)
 
#define SP_REG_CLASS_P(C) \
 
#define SP_REG_CLASS_P(C) \
 
  ((C) == CN_REG || (C) == LC_REG || (C) == SC_REG || (C) == SP_REGS)
 
  ((C) == CN_REG || (C) == LC_REG || (C) == SC_REG || (C) == SP_REGS)
 
#define CP_REG_CLASS_P(C) \
 
#define CP_REG_CLASS_P(C) \
 
  ((C) == CP1_REGS || (C) == CP2_REGS || (C) == CP3_REGS || (C) == CPA_REGS)
 
  ((C) == CP1_REGS || (C) == CP2_REGS || (C) == CP3_REGS || (C) == CPA_REGS)
 
#define CE_REG_CLASS_P(C) \
 
#define CE_REG_CLASS_P(C) \
 
  ((C) == HI_REG || (C) == LO_REG || (C) == CE_REGS)
 
  ((C) == HI_REG || (C) == LO_REG || (C) == CE_REGS)
 
 
 
 
 
static int score_arg_partial_bytes (const CUMULATIVE_ARGS *,
 
static int score_arg_partial_bytes (const CUMULATIVE_ARGS *,
 
                                    enum machine_mode, tree, int);
 
                                    enum machine_mode, tree, int);
 
 
 
 
 
static int score_symbol_insns (enum score_symbol_type);
 
static int score_symbol_insns (enum score_symbol_type);
 
 
 
 
 
static int score_address_insns (rtx, enum machine_mode);
 
static int score_address_insns (rtx, enum machine_mode);
 
 
 
 
 
static bool score_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *);
 
static bool score_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *);
 
 
 
 
 
static int score_address_cost (rtx);
 
static int score_address_cost (rtx);
 
 
 
 
 
#undef  TARGET_ASM_FILE_START
 
#undef  TARGET_ASM_FILE_START
 
#define TARGET_ASM_FILE_START           th_asm_file_start
 
#define TARGET_ASM_FILE_START           th_asm_file_start
 
 
 
 
 
#undef  TARGET_ASM_FILE_END
 
#undef  TARGET_ASM_FILE_END
 
#define TARGET_ASM_FILE_END             th_asm_file_end
 
#define TARGET_ASM_FILE_END             th_asm_file_end
 
 
 
 
 
#undef  TARGET_ASM_FUNCTION_PROLOGUE
 
#undef  TARGET_ASM_FUNCTION_PROLOGUE
 
#define TARGET_ASM_FUNCTION_PROLOGUE    th_function_prologue
 
#define TARGET_ASM_FUNCTION_PROLOGUE    th_function_prologue
 
 
 
 
 
#undef  TARGET_ASM_FUNCTION_EPILOGUE
 
#undef  TARGET_ASM_FUNCTION_EPILOGUE
 
#define TARGET_ASM_FUNCTION_EPILOGUE    th_function_epilogue
 
#define TARGET_ASM_FUNCTION_EPILOGUE    th_function_epilogue
 
 
 
 
 
#undef  TARGET_SCHED_ISSUE_RATE
 
#undef  TARGET_SCHED_ISSUE_RATE
 
#define TARGET_SCHED_ISSUE_RATE         th_issue_rate
 
#define TARGET_SCHED_ISSUE_RATE         th_issue_rate
 
 
 
 
 
#undef TARGET_ASM_SELECT_RTX_SECTION
 
#undef TARGET_ASM_SELECT_RTX_SECTION
 
#define TARGET_ASM_SELECT_RTX_SECTION   th_select_rtx_section
 
#define TARGET_ASM_SELECT_RTX_SECTION   th_select_rtx_section
 
 
 
 
 
#undef  TARGET_IN_SMALL_DATA_P
 
#undef  TARGET_IN_SMALL_DATA_P
 
#define TARGET_IN_SMALL_DATA_P          th_in_small_data_p
 
#define TARGET_IN_SMALL_DATA_P          th_in_small_data_p
 
 
 
 
 
#undef  TARGET_FUNCTION_OK_FOR_SIBCALL
 
#undef  TARGET_FUNCTION_OK_FOR_SIBCALL
 
#define TARGET_FUNCTION_OK_FOR_SIBCALL  th_function_ok_for_sibcall
 
#define TARGET_FUNCTION_OK_FOR_SIBCALL  th_function_ok_for_sibcall
 
 
 
 
 
#undef TARGET_STRICT_ARGUMENT_NAMING
 
#undef TARGET_STRICT_ARGUMENT_NAMING
 
#define TARGET_STRICT_ARGUMENT_NAMING   th_strict_argument_naming
 
#define TARGET_STRICT_ARGUMENT_NAMING   th_strict_argument_naming
 
 
 
 
 
#undef TARGET_ASM_OUTPUT_MI_THUNK
 
#undef TARGET_ASM_OUTPUT_MI_THUNK
 
#define TARGET_ASM_OUTPUT_MI_THUNK      th_output_mi_thunk
 
#define TARGET_ASM_OUTPUT_MI_THUNK      th_output_mi_thunk
 
 
 
 
 
#undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
 
#undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
 
#define TARGET_ASM_CAN_OUTPUT_MI_THUNK  hook_bool_tree_hwi_hwi_tree_true
 
#define TARGET_ASM_CAN_OUTPUT_MI_THUNK  hook_bool_tree_hwi_hwi_tree_true
 
 
 
 
 
#undef TARGET_PROMOTE_FUNCTION_ARGS
 
#undef TARGET_PROMOTE_FUNCTION_ARGS
 
#define TARGET_PROMOTE_FUNCTION_ARGS    hook_bool_tree_true
 
#define TARGET_PROMOTE_FUNCTION_ARGS    hook_bool_tree_true
 
 
 
 
 
#undef TARGET_PROMOTE_FUNCTION_RETURN
 
#undef TARGET_PROMOTE_FUNCTION_RETURN
 
#define TARGET_PROMOTE_FUNCTION_RETURN  hook_bool_tree_true
 
#define TARGET_PROMOTE_FUNCTION_RETURN  hook_bool_tree_true
 
 
 
 
 
#undef TARGET_PROMOTE_PROTOTYPES
 
#undef TARGET_PROMOTE_PROTOTYPES
 
#define TARGET_PROMOTE_PROTOTYPES       hook_bool_tree_true
 
#define TARGET_PROMOTE_PROTOTYPES       hook_bool_tree_true
 
 
 
 
 
#undef TARGET_MUST_PASS_IN_STACK
 
#undef TARGET_MUST_PASS_IN_STACK
 
#define TARGET_MUST_PASS_IN_STACK       must_pass_in_stack_var_size
 
#define TARGET_MUST_PASS_IN_STACK       must_pass_in_stack_var_size
 
 
 
 
 
#undef TARGET_ARG_PARTIAL_BYTES
 
#undef TARGET_ARG_PARTIAL_BYTES
 
#define TARGET_ARG_PARTIAL_BYTES        score_arg_partial_bytes
 
#define TARGET_ARG_PARTIAL_BYTES        score_arg_partial_bytes
 
 
 
 
 
#undef TARGET_PASS_BY_REFERENCE
 
#undef TARGET_PASS_BY_REFERENCE
 
#define TARGET_PASS_BY_REFERENCE        score_pass_by_reference
 
#define TARGET_PASS_BY_REFERENCE        score_pass_by_reference
 
 
 
 
 
#undef TARGET_RETURN_IN_MEMORY
 
#undef TARGET_RETURN_IN_MEMORY
 
#define TARGET_RETURN_IN_MEMORY         score_return_in_memory
 
#define TARGET_RETURN_IN_MEMORY         score_return_in_memory
 
 
 
 
 
#undef TARGET_RTX_COSTS
 
#undef TARGET_RTX_COSTS
 
#define TARGET_RTX_COSTS                score_rtx_costs
 
#define TARGET_RTX_COSTS                score_rtx_costs
 
 
 
 
 
#undef TARGET_ADDRESS_COST
 
#undef TARGET_ADDRESS_COST
 
#define TARGET_ADDRESS_COST             score_address_cost
 
#define TARGET_ADDRESS_COST             score_address_cost
 
 
 
 
 
#undef TARGET_DEFAULT_TARGET_FLAGS
 
#undef TARGET_DEFAULT_TARGET_FLAGS
 
#define TARGET_DEFAULT_TARGET_FLAGS     TARGET_DEFAULT
 
#define TARGET_DEFAULT_TARGET_FLAGS     TARGET_DEFAULT
 
 
 
 
 
/* Implement TARGET_RETURN_IN_MEMORY.  In S+core,
 
/* Implement TARGET_RETURN_IN_MEMORY.  In S+core,
 
   small structures are returned in a register.
 
   small structures are returned in a register.
 
   Objects with varying size must still be returned in memory.  */
 
   Objects with varying size must still be returned in memory.  */
 
static bool
 
static bool
 
score_return_in_memory (tree type, tree fndecl ATTRIBUTE_UNUSED)
 
score_return_in_memory (tree type, tree fndecl ATTRIBUTE_UNUSED)
 
{
 
{
 
  return ((TYPE_MODE (type) == BLKmode)
 
  return ((TYPE_MODE (type) == BLKmode)
 
          || (int_size_in_bytes (type) > 2 * UNITS_PER_WORD)
 
          || (int_size_in_bytes (type) > 2 * UNITS_PER_WORD)
 
          || (int_size_in_bytes (type) == -1));
 
          || (int_size_in_bytes (type) == -1));
 
}
 
}
 
 
 
 
 
/* Return nonzero when an argument must be passed by reference.  */
 
/* Return nonzero when an argument must be passed by reference.  */
 
static bool
 
static bool
 
score_pass_by_reference (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
 
score_pass_by_reference (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
 
                         enum machine_mode mode, tree type,
 
                         enum machine_mode mode, tree type,
 
                         bool named ATTRIBUTE_UNUSED)
 
                         bool named ATTRIBUTE_UNUSED)
 
{
 
{
 
  /* If we have a variable-sized parameter, we have no choice.  */
 
  /* If we have a variable-sized parameter, we have no choice.  */
 
  return targetm.calls.must_pass_in_stack (mode, type);
 
  return targetm.calls.must_pass_in_stack (mode, type);
 
}
 
}
 
 
 
 
 
/* Return a legitimate address for REG + OFFSET.  */
 
/* Return a legitimate address for REG + OFFSET.  */
 
static rtx
 
static rtx
 
score_add_offset (rtx temp, rtx reg, HOST_WIDE_INT offset)
 
score_add_offset (rtx temp, rtx reg, HOST_WIDE_INT offset)
 
{
 
{
 
  if (!IMM_IN_RANGE (offset, 15, 1))
 
  if (!IMM_IN_RANGE (offset, 15, 1))
 
    {
 
    {
 
      reg = expand_simple_binop (GET_MODE (reg), PLUS,
 
      reg = expand_simple_binop (GET_MODE (reg), PLUS,
 
                                 gen_int_mode (offset & 0xffffc000,
 
                                 gen_int_mode (offset & 0xffffc000,
 
                                               GET_MODE (reg)),
 
                                               GET_MODE (reg)),
 
                                 reg, NULL, 0, OPTAB_WIDEN);
 
                                 reg, NULL, 0, OPTAB_WIDEN);
 
      offset &= 0x3fff;
 
      offset &= 0x3fff;
 
    }
 
    }
 
 
 
 
 
  return plus_constant (reg, offset);
 
  return plus_constant (reg, offset);
 
}
 
}
 
 
 
 
 
/* Implement TARGET_ASM_OUTPUT_MI_THUNK.  Generate rtl rather than asm text
 
/* Implement TARGET_ASM_OUTPUT_MI_THUNK.  Generate rtl rather than asm text
 
   in order to avoid duplicating too much logic from elsewhere.  */
 
   in order to avoid duplicating too much logic from elsewhere.  */
 
static void
 
static void
 
th_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
 
th_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
 
                    HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
 
                    HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
 
                    tree function)
 
                    tree function)
 
{
 
{
 
  rtx this, temp1, temp2, insn, fnaddr;
 
  rtx this, temp1, temp2, insn, fnaddr;
 
 
 
 
 
  /* Pretend to be a post-reload pass while generating rtl.  */
 
  /* Pretend to be a post-reload pass while generating rtl.  */
 
  no_new_pseudos = 1;
 
  no_new_pseudos = 1;
 
  reload_completed = 1;
 
  reload_completed = 1;
 
  reset_block_changes ();
 
  reset_block_changes ();
 
 
 
 
 
  /* We need two temporary registers in some cases.  */
 
  /* We need two temporary registers in some cases.  */
 
  temp1 = gen_rtx_REG (Pmode, 8);
 
  temp1 = gen_rtx_REG (Pmode, 8);
 
  temp2 = gen_rtx_REG (Pmode, 9);
 
  temp2 = gen_rtx_REG (Pmode, 9);
 
 
 
 
 
  /* Find out which register contains the "this" pointer.  */
 
  /* Find out which register contains the "this" pointer.  */
 
  if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
 
  if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
 
    this = gen_rtx_REG (Pmode, ARG_REG_FIRST + 1);
 
    this = gen_rtx_REG (Pmode, ARG_REG_FIRST + 1);
 
  else
 
  else
 
    this = gen_rtx_REG (Pmode, ARG_REG_FIRST);
 
    this = gen_rtx_REG (Pmode, ARG_REG_FIRST);
 
 
 
 
 
  /* Add DELTA to THIS.  */
 
  /* Add DELTA to THIS.  */
 
  if (delta != 0)
 
  if (delta != 0)
 
    {
 
    {
 
      rtx offset = GEN_INT (delta);
 
      rtx offset = GEN_INT (delta);
 
      if (!CONST_OK_FOR_LETTER_P (delta, 'L'))
 
      if (!CONST_OK_FOR_LETTER_P (delta, 'L'))
 
        {
 
        {
 
          emit_move_insn (temp1, offset);
 
          emit_move_insn (temp1, offset);
 
          offset = temp1;
 
          offset = temp1;
 
        }
 
        }
 
      emit_insn (gen_add3_insn (this, this, offset));
 
      emit_insn (gen_add3_insn (this, this, offset));
 
    }
 
    }
 
 
 
 
 
  /* If needed, add *(*THIS + VCALL_OFFSET) to THIS.  */
 
  /* If needed, add *(*THIS + VCALL_OFFSET) to THIS.  */
 
  if (vcall_offset != 0)
 
  if (vcall_offset != 0)
 
    {
 
    {
 
      rtx addr;
 
      rtx addr;
 
 
 
 
 
      /* Set TEMP1 to *THIS.  */
 
      /* Set TEMP1 to *THIS.  */
 
      emit_move_insn (temp1, gen_rtx_MEM (Pmode, this));
 
      emit_move_insn (temp1, gen_rtx_MEM (Pmode, this));
 
 
 
 
 
      /* Set ADDR to a legitimate address for *THIS + VCALL_OFFSET.  */
 
      /* Set ADDR to a legitimate address for *THIS + VCALL_OFFSET.  */
 
      addr = score_add_offset (temp2, temp1, vcall_offset);
 
      addr = score_add_offset (temp2, temp1, vcall_offset);
 
 
 
 
 
      /* Load the offset and add it to THIS.  */
 
      /* Load the offset and add it to THIS.  */
 
      emit_move_insn (temp1, gen_rtx_MEM (Pmode, addr));
 
      emit_move_insn (temp1, gen_rtx_MEM (Pmode, addr));
 
      emit_insn (gen_add3_insn (this, this, temp1));
 
      emit_insn (gen_add3_insn (this, this, temp1));
 
    }
 
    }
 
 
 
 
 
  /* Jump to the target function.  */
 
  /* Jump to the target function.  */
 
  fnaddr = XEXP (DECL_RTL (function), 0);
 
  fnaddr = XEXP (DECL_RTL (function), 0);
 
  insn = emit_call_insn (gen_sibcall_internal (fnaddr, const0_rtx));
 
  insn = emit_call_insn (gen_sibcall_internal (fnaddr, const0_rtx));
 
  SIBLING_CALL_P (insn) = 1;
 
  SIBLING_CALL_P (insn) = 1;
 
 
 
 
 
  /* Run just enough of rest_of_compilation.  This sequence was
 
  /* Run just enough of rest_of_compilation.  This sequence was
 
     "borrowed" from alpha.c.  */
 
     "borrowed" from alpha.c.  */
 
  insn = get_insns ();
 
  insn = get_insns ();
 
  insn_locators_initialize ();
 
  insn_locators_initialize ();
 
  split_all_insns_noflow ();
 
  split_all_insns_noflow ();
 
  shorten_branches (insn);
 
  shorten_branches (insn);
 
  final_start_function (insn, file, 1);
 
  final_start_function (insn, file, 1);
 
  final (insn, file, 1);
 
  final (insn, file, 1);
 
  final_end_function ();
 
  final_end_function ();
 
 
 
 
 
  /* Clean up the vars set above.  Note that final_end_function resets
 
  /* Clean up the vars set above.  Note that final_end_function resets
 
     the global pointer for us.  */
 
     the global pointer for us.  */
 
  reload_completed = 0;
 
  reload_completed = 0;
 
  no_new_pseudos = 0;
 
  no_new_pseudos = 0;
 
}
 
}
 
 
 
 
 
/* Implement TARGET_STRICT_ARGUMENT_NAMING.  */
 
/* Implement TARGET_STRICT_ARGUMENT_NAMING.  */
 
static bool
 
static bool
 
th_strict_argument_naming (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
 
th_strict_argument_naming (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
 
{
 
{
 
  return true;
 
  return true;
 
}
 
}
 
 
 
 
 
/* Implement TARGET_FUNCTION_OK_FOR_SIBCALL.  */
 
/* Implement TARGET_FUNCTION_OK_FOR_SIBCALL.  */
 
static bool
 
static bool
 
th_function_ok_for_sibcall (ATTRIBUTE_UNUSED tree decl,
 
th_function_ok_for_sibcall (ATTRIBUTE_UNUSED tree decl,
 
                            ATTRIBUTE_UNUSED tree exp)
 
                            ATTRIBUTE_UNUSED tree exp)
 
{
 
{
 
  return true;
 
  return true;
 
}
 
}
 
 
 
 
 
struct score_arg_info
 
struct score_arg_info
 
{
 
{
 
  /* The argument's size, in bytes.  */
 
  /* The argument's size, in bytes.  */
 
  unsigned int num_bytes;
 
  unsigned int num_bytes;
 
 
 
 
 
  /* The number of words passed in registers, rounded up.  */
 
  /* The number of words passed in registers, rounded up.  */
 
  unsigned int reg_words;
 
  unsigned int reg_words;
 
 
 
 
 
  /* The offset of the first register from GP_ARG_FIRST or FP_ARG_FIRST,
 
  /* The offset of the first register from GP_ARG_FIRST or FP_ARG_FIRST,
 
     or ARG_REG_NUM if the argument is passed entirely on the stack.  */
 
     or ARG_REG_NUM if the argument is passed entirely on the stack.  */
 
  unsigned int reg_offset;
 
  unsigned int reg_offset;
 
 
 
 
 
  /* The number of words that must be passed on the stack, rounded up.  */
 
  /* The number of words that must be passed on the stack, rounded up.  */
 
  unsigned int stack_words;
 
  unsigned int stack_words;
 
 
 
 
 
  /* The offset from the start of the stack overflow area of the argument's
 
  /* The offset from the start of the stack overflow area of the argument's
 
     first stack word.  Only meaningful when STACK_WORDS is nonzero.  */
 
     first stack word.  Only meaningful when STACK_WORDS is nonzero.  */
 
  unsigned int stack_offset;
 
  unsigned int stack_offset;
 
};
 
};
 
 
 
 
 
/* Fill INFO with information about a single argument.  CUM is the
 
/* Fill INFO with information about a single argument.  CUM is the
 
   cumulative state for earlier arguments.  MODE is the mode of this
 
   cumulative state for earlier arguments.  MODE is the mode of this
 
   argument and TYPE is its type (if known).  NAMED is true if this
 
   argument and TYPE is its type (if known).  NAMED is true if this
 
   is a named (fixed) argument rather than a variable one.  */
 
   is a named (fixed) argument rather than a variable one.  */
 
static void
 
static void
 
classify_arg (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
 
classify_arg (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
 
              tree type, int named, struct score_arg_info *info)
 
              tree type, int named, struct score_arg_info *info)
 
{
 
{
 
  int even_reg_p;
 
  int even_reg_p;
 
  unsigned int num_words, max_regs;
 
  unsigned int num_words, max_regs;
 
 
 
 
 
  even_reg_p = 0;
 
  even_reg_p = 0;
 
  if (GET_MODE_CLASS (mode) == MODE_INT
 
  if (GET_MODE_CLASS (mode) == MODE_INT
 
      || GET_MODE_CLASS (mode) == MODE_FLOAT)
 
      || GET_MODE_CLASS (mode) == MODE_FLOAT)
 
    even_reg_p = (GET_MODE_SIZE (mode) > UNITS_PER_WORD);
 
    even_reg_p = (GET_MODE_SIZE (mode) > UNITS_PER_WORD);
 
  else
 
  else
 
    if (type != NULL_TREE && TYPE_ALIGN (type) > BITS_PER_WORD && named)
 
    if (type != NULL_TREE && TYPE_ALIGN (type) > BITS_PER_WORD && named)
 
      even_reg_p = 1;
 
      even_reg_p = 1;
 
 
 
 
 
  if (TARGET_MUST_PASS_IN_STACK (mode, type))
 
  if (TARGET_MUST_PASS_IN_STACK (mode, type))
 
    info->reg_offset = ARG_REG_NUM;
 
    info->reg_offset = ARG_REG_NUM;
 
  else
 
  else
 
    {
 
    {
 
      info->reg_offset = cum->num_gprs;
 
      info->reg_offset = cum->num_gprs;
 
      if (even_reg_p)
 
      if (even_reg_p)
 
        info->reg_offset += info->reg_offset & 1;
 
        info->reg_offset += info->reg_offset & 1;
 
    }
 
    }
 
 
 
 
 
  if (mode == BLKmode)
 
  if (mode == BLKmode)
 
    info->num_bytes = int_size_in_bytes (type);
 
    info->num_bytes = int_size_in_bytes (type);
 
  else
 
  else
 
    info->num_bytes = GET_MODE_SIZE (mode);
 
    info->num_bytes = GET_MODE_SIZE (mode);
 
 
 
 
 
  num_words = (info->num_bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
 
  num_words = (info->num_bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
 
  max_regs = ARG_REG_NUM - info->reg_offset;
 
  max_regs = ARG_REG_NUM - info->reg_offset;
 
 
 
 
 
  /* Partition the argument between registers and stack.  */
 
  /* Partition the argument between registers and stack.  */
 
  info->reg_words = MIN (num_words, max_regs);
 
  info->reg_words = MIN (num_words, max_regs);
 
  info->stack_words = num_words - info->reg_words;
 
  info->stack_words = num_words - info->reg_words;
 
 
 
 
 
  /* The alignment applied to registers is also applied to stack arguments.  */
 
  /* The alignment applied to registers is also applied to stack arguments.  */
 
  if (info->stack_words)
 
  if (info->stack_words)
 
    {
 
    {
 
      info->stack_offset = cum->stack_words;
 
      info->stack_offset = cum->stack_words;
 
      if (even_reg_p)
 
      if (even_reg_p)
 
        info->stack_offset += info->stack_offset & 1;
 
        info->stack_offset += info->stack_offset & 1;
 
    }
 
    }
 
}
 
}
 
 
 
 
 
/* Set up the stack and frame (if desired) for the function.  */
 
/* Set up the stack and frame (if desired) for the function.  */
 
static void
 
static void
 
th_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
 
th_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
 
{
 
{
 
  const char *fnname;
 
  const char *fnname;
 
  struct score_frame_info *f = mda_cached_frame ();
 
  struct score_frame_info *f = mda_cached_frame ();
 
  HOST_WIDE_INT tsize = f->total_size;
 
  HOST_WIDE_INT tsize = f->total_size;
 
 
 
 
 
  fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
 
  fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
 
  if (!flag_inhibit_size_directive)
 
  if (!flag_inhibit_size_directive)
 
    {
 
    {
 
      fputs ("\t.ent\t", file);
 
      fputs ("\t.ent\t", file);
 
      assemble_name (file, fnname);
 
      assemble_name (file, fnname);
 
      fputs ("\n", file);
 
      fputs ("\n", file);
 
    }
 
    }
 
  assemble_name (file, fnname);
 
  assemble_name (file, fnname);
 
  fputs (":\n", file);
 
  fputs (":\n", file);
 
 
 
 
 
  if (!flag_inhibit_size_directive)
 
  if (!flag_inhibit_size_directive)
 
    {
 
    {
 
      fprintf (file,
 
      fprintf (file,
 
               "\t.frame\t%s," HOST_WIDE_INT_PRINT_DEC ",%s, %d\t\t"
 
               "\t.frame\t%s," HOST_WIDE_INT_PRINT_DEC ",%s, %d\t\t"
 
               "# vars= " HOST_WIDE_INT_PRINT_DEC ", regs= %d"
 
               "# vars= " HOST_WIDE_INT_PRINT_DEC ", regs= %d"
 
               ", args= " HOST_WIDE_INT_PRINT_DEC
 
               ", args= " HOST_WIDE_INT_PRINT_DEC
 
               ", gp= " HOST_WIDE_INT_PRINT_DEC "\n",
 
               ", gp= " HOST_WIDE_INT_PRINT_DEC "\n",
 
               (reg_names[(frame_pointer_needed)
 
               (reg_names[(frame_pointer_needed)
 
                ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM]),
 
                ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM]),
 
               tsize,
 
               tsize,
 
               reg_names[RA_REGNUM],
 
               reg_names[RA_REGNUM],
 
               current_function_is_leaf ? 1 : 0,
 
               current_function_is_leaf ? 1 : 0,
 
               f->var_size,
 
               f->var_size,
 
               f->num_gp,
 
               f->num_gp,
 
               f->args_size,
 
               f->args_size,
 
               f->cprestore_size);
 
               f->cprestore_size);
 
 
 
 
 
      fprintf(file, "\t.mask\t0x%08x," HOST_WIDE_INT_PRINT_DEC "\n",
 
      fprintf(file, "\t.mask\t0x%08x," HOST_WIDE_INT_PRINT_DEC "\n",
 
              f->mask,
 
              f->mask,
 
              (f->gp_sp_offset - f->total_size));
 
              (f->gp_sp_offset - f->total_size));
 
    }
 
    }
 
}
 
}
 
 
 
 
 
/* Do any necessary cleanup after a function to restore stack, frame,
 
/* Do any necessary cleanup after a function to restore stack, frame,
 
   and regs.  */
 
   and regs.  */
 
static void
 
static void
 
th_function_epilogue (FILE *file,
 
th_function_epilogue (FILE *file,
 
                      HOST_WIDE_INT size ATTRIBUTE_UNUSED)
 
                      HOST_WIDE_INT size ATTRIBUTE_UNUSED)
 
{
 
{
 
  if (!flag_inhibit_size_directive)
 
  if (!flag_inhibit_size_directive)
 
    {
 
    {
 
      const char *fnname;
 
      const char *fnname;
 
      fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
 
      fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
 
      fputs ("\t.end\t", file);
 
      fputs ("\t.end\t", file);
 
      assemble_name (file, fnname);
 
      assemble_name (file, fnname);
 
      fputs ("\n", file);
 
      fputs ("\n", file);
 
    }
 
    }
 
}
 
}
 
 
 
 
 
/* Implement TARGET_SCHED_ISSUE_RATE.  */
 
/* Implement TARGET_SCHED_ISSUE_RATE.  */
 
static int
 
static int
 
th_issue_rate (void)
 
th_issue_rate (void)
 
{
 
{
 
  return 1;
 
  return 1;
 
}
 
}
 
 
 
 
 
/* Returns true if X contains a SYMBOL_REF.  */
 
/* Returns true if X contains a SYMBOL_REF.  */
 
static bool
 
static bool
 
symbolic_expression_p (rtx x)
 
symbolic_expression_p (rtx x)
 
{
 
{
 
  if (GET_CODE (x) == SYMBOL_REF)
 
  if (GET_CODE (x) == SYMBOL_REF)
 
    return true;
 
    return true;
 
 
 
 
 
  if (GET_CODE (x) == CONST)
 
  if (GET_CODE (x) == CONST)
 
    return symbolic_expression_p (XEXP (x, 0));
 
    return symbolic_expression_p (XEXP (x, 0));
 
 
 
 
 
  if (UNARY_P (x))
 
  if (UNARY_P (x))
 
    return symbolic_expression_p (XEXP (x, 0));
 
    return symbolic_expression_p (XEXP (x, 0));
 
 
 
 
 
  if (ARITHMETIC_P (x))
 
  if (ARITHMETIC_P (x))
 
    return (symbolic_expression_p (XEXP (x, 0))
 
    return (symbolic_expression_p (XEXP (x, 0))
 
            || symbolic_expression_p (XEXP (x, 1)));
 
            || symbolic_expression_p (XEXP (x, 1)));
 
 
 
 
 
  return false;
 
  return false;
 
}
 
}
 
 
 
 
 
/* Choose the section to use for the constant rtx expression X that has
 
/* Choose the section to use for the constant rtx expression X that has
 
   mode MODE.  */
 
   mode MODE.  */
 
static section *
 
static section *
 
th_select_rtx_section (enum machine_mode mode, rtx x,
 
th_select_rtx_section (enum machine_mode mode, rtx x,
 
                       unsigned HOST_WIDE_INT align)
 
                       unsigned HOST_WIDE_INT align)
 
{
 
{
 
  if (GET_MODE_SIZE (mode) <= SCORE_SDATA_MAX)
 
  if (GET_MODE_SIZE (mode) <= SCORE_SDATA_MAX)
 
    return get_named_section (0, ".sdata", 0);
 
    return get_named_section (0, ".sdata", 0);
 
  else if (flag_pic && symbolic_expression_p (x))
 
  else if (flag_pic && symbolic_expression_p (x))
 
    return get_named_section (0, ".data.rel.ro", 3);
 
    return get_named_section (0, ".data.rel.ro", 3);
 
  else
 
  else
 
    return mergeable_constant_section (mode, align, 0);
 
    return mergeable_constant_section (mode, align, 0);
 
}
 
}
 
 
 
 
 
/* Implement TARGET_IN_SMALL_DATA_P.  */
 
/* Implement TARGET_IN_SMALL_DATA_P.  */
 
static bool
 
static bool
 
th_in_small_data_p (tree decl)
 
th_in_small_data_p (tree decl)
 
{
 
{
 
  HOST_WIDE_INT size;
 
  HOST_WIDE_INT size;
 
 
 
 
 
  if (TREE_CODE (decl) == STRING_CST
 
  if (TREE_CODE (decl) == STRING_CST
 
      || TREE_CODE (decl) == FUNCTION_DECL)
 
      || TREE_CODE (decl) == FUNCTION_DECL)
 
    return false;
 
    return false;
 
 
 
 
 
  if (TREE_CODE (decl) == VAR_DECL && DECL_SECTION_NAME (decl) != 0)
 
  if (TREE_CODE (decl) == VAR_DECL && DECL_SECTION_NAME (decl) != 0)
 
    {
 
    {
 
      const char *name;
 
      const char *name;
 
      name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
 
      name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
 
      if (strcmp (name, ".sdata") != 0
 
      if (strcmp (name, ".sdata") != 0
 
          && strcmp (name, ".sbss") != 0)
 
          && strcmp (name, ".sbss") != 0)
 
        return true;
 
        return true;
 
      if (!DECL_EXTERNAL (decl))
 
      if (!DECL_EXTERNAL (decl))
 
        return false;
 
        return false;
 
    }
 
    }
 
  size = int_size_in_bytes (TREE_TYPE (decl));
 
  size = int_size_in_bytes (TREE_TYPE (decl));
 
  return (size > 0 && size <= SCORE_SDATA_MAX);
 
  return (size > 0 && size <= SCORE_SDATA_MAX);
 
}
 
}
 
 
 
 
 
/* Implement TARGET_ASM_FILE_START.  */
 
/* Implement TARGET_ASM_FILE_START.  */
 
static void
 
static void
 
th_asm_file_start (void)
 
th_asm_file_start (void)
 
{
 
{
 
  default_file_start ();
 
  default_file_start ();
 
  fprintf (asm_out_file, ASM_COMMENT_START
 
  fprintf (asm_out_file, ASM_COMMENT_START
 
           "GCC for S+core %s \n", SCORE_GCC_VERSION);
 
           "GCC for S+core %s \n", SCORE_GCC_VERSION);
 
 
 
 
 
  if (flag_pic)
 
  if (flag_pic)
 
    fprintf (asm_out_file, "\t.set pic\n");
 
    fprintf (asm_out_file, "\t.set pic\n");
 
}
 
}
 
 
 
 
 
/* Implement TARGET_ASM_FILE_END.  When using assembler macros, emit
 
/* Implement TARGET_ASM_FILE_END.  When using assembler macros, emit
 
   .externs for any small-data variables that turned out to be external.  */
 
   .externs for any small-data variables that turned out to be external.  */
 
struct extern_list *extern_head = 0;
 
struct extern_list *extern_head = 0;
 
 
 
 
 
static void
 
static void
 
th_asm_file_end (void)
 
th_asm_file_end (void)
 
{
 
{
 
  tree name_tree;
 
  tree name_tree;
 
  struct extern_list *p;
 
  struct extern_list *p;
 
  if (extern_head)
 
  if (extern_head)
 
    {
 
    {
 
      fputs ("\n", asm_out_file);
 
      fputs ("\n", asm_out_file);
 
      for (p = extern_head; p != 0; p = p->next)
 
      for (p = extern_head; p != 0; p = p->next)
 
        {
 
        {
 
          name_tree = get_identifier (p->name);
 
          name_tree = get_identifier (p->name);
 
          if (!TREE_ASM_WRITTEN (name_tree)
 
          if (!TREE_ASM_WRITTEN (name_tree)
 
              && TREE_SYMBOL_REFERENCED (name_tree))
 
              && TREE_SYMBOL_REFERENCED (name_tree))
 
            {
 
            {
 
              TREE_ASM_WRITTEN (name_tree) = 1;
 
              TREE_ASM_WRITTEN (name_tree) = 1;
 
              fputs ("\t.extern\t", asm_out_file);
 
              fputs ("\t.extern\t", asm_out_file);
 
              assemble_name (asm_out_file, p->name);
 
              assemble_name (asm_out_file, p->name);
 
              fprintf (asm_out_file, ", %d\n", p->size);
 
              fprintf (asm_out_file, ", %d\n", p->size);
 
            }
 
            }
 
        }
 
        }
 
    }
 
    }
 
}
 
}
 
 
 
 
 
static unsigned int sdata_max;
 
static unsigned int sdata_max;
 
 
 
 
 
int
 
int
 
score_sdata_max (void)
 
score_sdata_max (void)
 
{
 
{
 
  return sdata_max;
 
  return sdata_max;
 
}
 
}
 
 
 
 
 
/* default 0 = NO_REGS  */
 
/* default 0 = NO_REGS  */
 
enum reg_class score_char_to_class[256];
 
enum reg_class score_char_to_class[256];
 
 
 
 
 
/* Implement OVERRIDE_OPTIONS macro.  */
 
/* Implement OVERRIDE_OPTIONS macro.  */
 
void
 
void
 
score_override_options (void)
 
score_override_options (void)
 
{
 
{
 
  flag_pic = false;
 
  flag_pic = false;
 
  if (!flag_pic)
 
  if (!flag_pic)
 
    sdata_max = g_switch_set ? g_switch_value : DEFAULT_SDATA_MAX;
 
    sdata_max = g_switch_set ? g_switch_value : DEFAULT_SDATA_MAX;
 
  else
 
  else
 
    {
 
    {
 
      sdata_max = 0;
 
      sdata_max = 0;
 
      if (g_switch_set && (g_switch_value != 0))
 
      if (g_switch_set && (g_switch_value != 0))
 
        warning (0, "-fPIC and -G are incompatible");
 
        warning (0, "-fPIC and -G are incompatible");
 
    }
 
    }
 
 
 
 
 
  score_char_to_class['d'] = G32_REGS;
 
  score_char_to_class['d'] = G32_REGS;
 
  score_char_to_class['e'] = G16_REGS;
 
  score_char_to_class['e'] = G16_REGS;
 
  score_char_to_class['t'] = T32_REGS;
 
  score_char_to_class['t'] = T32_REGS;
 
 
 
 
 
  score_char_to_class['h'] = HI_REG;
 
  score_char_to_class['h'] = HI_REG;
 
  score_char_to_class['l'] = LO_REG;
 
  score_char_to_class['l'] = LO_REG;
 
  score_char_to_class['x'] = CE_REGS;
 
  score_char_to_class['x'] = CE_REGS;
 
 
 
 
 
  score_char_to_class['q'] = CN_REG;
 
  score_char_to_class['q'] = CN_REG;
 
  score_char_to_class['y'] = LC_REG;
 
  score_char_to_class['y'] = LC_REG;
 
  score_char_to_class['z'] = SC_REG;
 
  score_char_to_class['z'] = SC_REG;
 
  score_char_to_class['a'] = SP_REGS;
 
  score_char_to_class['a'] = SP_REGS;
 
 
 
 
 
  score_char_to_class['c'] = CR_REGS;
 
  score_char_to_class['c'] = CR_REGS;
 
 
 
 
 
  score_char_to_class['b'] = CP1_REGS;
 
  score_char_to_class['b'] = CP1_REGS;
 
  score_char_to_class['f'] = CP2_REGS;
 
  score_char_to_class['f'] = CP2_REGS;
 
  score_char_to_class['i'] = CP3_REGS;
 
  score_char_to_class['i'] = CP3_REGS;
 
  score_char_to_class['j'] = CPA_REGS;
 
  score_char_to_class['j'] = CPA_REGS;
 
}
 
}
 
 
 
 
 
/* Implement REGNO_REG_CLASS macro.  */
 
/* Implement REGNO_REG_CLASS macro.  */
 
int
 
int
 
score_reg_class (int regno)
 
score_reg_class (int regno)
 
{
 
{
 
  int c;
 
  int c;
 
  gcc_assert (regno >= 0 && regno < FIRST_PSEUDO_REGISTER);
 
  gcc_assert (regno >= 0 && regno < FIRST_PSEUDO_REGISTER);
 
 
 
 
 
  if (regno == FRAME_POINTER_REGNUM
 
  if (regno == FRAME_POINTER_REGNUM
 
      || regno == ARG_POINTER_REGNUM)
 
      || regno == ARG_POINTER_REGNUM)
 
    return ALL_REGS;
 
    return ALL_REGS;
 
 
 
 
 
  for (c = 0; c < N_REG_CLASSES; c++)
 
  for (c = 0; c < N_REG_CLASSES; c++)
 
    if (TEST_HARD_REG_BIT (reg_class_contents[c], regno))
 
    if (TEST_HARD_REG_BIT (reg_class_contents[c], regno))
 
      return c;
 
      return c;
 
 
 
 
 
  return NO_REGS;
 
  return NO_REGS;
 
}
 
}
 
 
 
 
 
/* Implement PREFERRED_RELOAD_CLASS macro.  */
 
/* Implement PREFERRED_RELOAD_CLASS macro.  */
 
enum reg_class
 
enum reg_class
 
score_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class class)
 
score_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class class)
 
{
 
{
 
  if (reg_class_subset_p (G16_REGS, class))
 
  if (reg_class_subset_p (G16_REGS, class))
 
    return G16_REGS;
 
    return G16_REGS;
 
  if (reg_class_subset_p (G32_REGS, class))
 
  if (reg_class_subset_p (G32_REGS, class))
 
    return G32_REGS;
 
    return G32_REGS;
 
  return class;
 
  return class;
 
}
 
}
 
 
 
 
 
/* Implement SECONDARY_INPUT_RELOAD_CLASS
 
/* Implement SECONDARY_INPUT_RELOAD_CLASS
 
   and SECONDARY_OUTPUT_RELOAD_CLASS macro.  */
 
   and SECONDARY_OUTPUT_RELOAD_CLASS macro.  */
 
enum reg_class
 
enum reg_class
 
score_secondary_reload_class (enum reg_class class,
 
score_secondary_reload_class (enum reg_class class,
 
                              enum machine_mode mode ATTRIBUTE_UNUSED,
 
                              enum machine_mode mode ATTRIBUTE_UNUSED,
 
                              rtx x)
 
                              rtx x)
 
{
 
{
 
  int regno = -1;
 
  int regno = -1;
 
  if (GET_CODE (x) == REG || GET_CODE(x) == SUBREG)
 
  if (GET_CODE (x) == REG || GET_CODE(x) == SUBREG)
 
    regno = true_regnum (x);
 
    regno = true_regnum (x);
 
 
 
 
 
  if (!GR_REG_CLASS_P (class))
 
  if (!GR_REG_CLASS_P (class))
 
    return GP_REG_P (regno) ? NO_REGS : G32_REGS;
 
    return GP_REG_P (regno) ? NO_REGS : G32_REGS;
 
  return NO_REGS;
 
  return NO_REGS;
 
}
 
}
 
 
 
 
 
/* Implement CONST_OK_FOR_LETTER_P macro.  */
 
/* Implement CONST_OK_FOR_LETTER_P macro.  */
 
/* imm constraints
 
/* imm constraints
 
   I        imm16 << 16
 
   I        imm16 << 16
 
   J        uimm5
 
   J        uimm5
 
   K        uimm16
 
   K        uimm16
 
   L        simm16
 
   L        simm16
 
   M        uimm14
 
   M        uimm14
 
   N        simm14  */
 
   N        simm14  */
 
int
 
int
 
score_const_ok_for_letter_p (HOST_WIDE_INT value, char c)
 
score_const_ok_for_letter_p (HOST_WIDE_INT value, char c)
 
{
 
{
 
  switch (c)
 
  switch (c)
 
    {
 
    {
 
    case 'I': return ((value & 0xffff) == 0);
 
    case 'I': return ((value & 0xffff) == 0);
 
    case 'J': return IMM_IN_RANGE (value, 5, 0);
 
    case 'J': return IMM_IN_RANGE (value, 5, 0);
 
    case 'K': return IMM_IN_RANGE (value, 16, 0);
 
    case 'K': return IMM_IN_RANGE (value, 16, 0);
 
    case 'L': return IMM_IN_RANGE (value, 16, 1);
 
    case 'L': return IMM_IN_RANGE (value, 16, 1);
 
    case 'M': return IMM_IN_RANGE (value, 14, 0);
 
    case 'M': return IMM_IN_RANGE (value, 14, 0);
 
    case 'N': return IMM_IN_RANGE (value, 14, 1);
 
    case 'N': return IMM_IN_RANGE (value, 14, 1);
 
    default : return 0;
 
    default : return 0;
 
    }
 
    }
 
}
 
}
 
 
 
 
 
/* Implement EXTRA_CONSTRAINT macro.  */
 
/* Implement EXTRA_CONSTRAINT macro.  */
 
/* Z        symbol_ref  */
 
/* Z        symbol_ref  */
 
int
 
int
 
score_extra_constraint (rtx op, char c)
 
score_extra_constraint (rtx op, char c)
 
{
 
{
 
  switch (c)
 
  switch (c)
 
    {
 
    {
 
    case 'Z':
 
    case 'Z':
 
      return GET_CODE (op) == SYMBOL_REF;
 
      return GET_CODE (op) == SYMBOL_REF;
 
    default:
 
    default:
 
      gcc_unreachable ();
 
      gcc_unreachable ();
 
    }
 
    }
 
}
 
}
 
 
 
 
 
/* Return truth value on whether or not a given hard register
 
/* Return truth value on whether or not a given hard register
 
   can support a given mode.  */
 
   can support a given mode.  */
 
int
 
int
 
score_hard_regno_mode_ok (unsigned int regno, enum machine_mode mode)
 
score_hard_regno_mode_ok (unsigned int regno, enum machine_mode mode)
 
{
 
{
 
  int size = GET_MODE_SIZE (mode);
 
  int size = GET_MODE_SIZE (mode);
 
  enum mode_class class = GET_MODE_CLASS (mode);
 
  enum mode_class class = GET_MODE_CLASS (mode);
 
 
 
 
 
  if (class == MODE_CC)
 
  if (class == MODE_CC)
 
    return regno == CC_REGNUM;
 
    return regno == CC_REGNUM;
 
  else if (regno == FRAME_POINTER_REGNUM
 
  else if (regno == FRAME_POINTER_REGNUM
 
           || regno == ARG_POINTER_REGNUM)
 
           || regno == ARG_POINTER_REGNUM)
 
    return class == MODE_INT;
 
    return class == MODE_INT;
 
  else if (GP_REG_P (regno))
 
  else if (GP_REG_P (regno))
 
    /* ((regno <= (GP_REG_LAST- HARD_REGNO_NREGS (dummy, mode)) + 1)  */
 
    /* ((regno <= (GP_REG_LAST- HARD_REGNO_NREGS (dummy, mode)) + 1)  */
 
    return !(regno & 1) || (size <= UNITS_PER_WORD);
 
    return !(regno & 1) || (size <= UNITS_PER_WORD);
 
  else if (CE_REG_P (regno))
 
  else if (CE_REG_P (regno))
 
    return (class == MODE_INT
 
    return (class == MODE_INT
 
            && ((size <= UNITS_PER_WORD)
 
            && ((size <= UNITS_PER_WORD)
 
                || (regno == CE_REG_FIRST && size == 2 * UNITS_PER_WORD)));
 
                || (regno == CE_REG_FIRST && size == 2 * UNITS_PER_WORD)));
 
  else
 
  else
 
    return (class == MODE_INT) && (size <= UNITS_PER_WORD);
 
    return (class == MODE_INT) && (size <= UNITS_PER_WORD);
 
}
 
}
 
 
 
 
 
/* Implement INITIAL_ELIMINATION_OFFSET.  FROM is either the frame
 
/* Implement INITIAL_ELIMINATION_OFFSET.  FROM is either the frame
 
   pointer or argument pointer.  TO is either the stack pointer or
 
   pointer or argument pointer.  TO is either the stack pointer or
 
   hard frame pointer.  */
 
   hard frame pointer.  */
 
HOST_WIDE_INT
 
HOST_WIDE_INT
 
score_initial_elimination_offset (int from,
 
score_initial_elimination_offset (int from,
 
                                  int to ATTRIBUTE_UNUSED)
 
                                  int to ATTRIBUTE_UNUSED)
 
{
 
{
 
  struct score_frame_info *f = mda_compute_frame_size (get_frame_size ());
 
  struct score_frame_info *f = mda_compute_frame_size (get_frame_size ());
 
  switch (from)
 
  switch (from)
 
    {
 
    {
 
    case ARG_POINTER_REGNUM:
 
    case ARG_POINTER_REGNUM:
 
      return f->total_size;
 
      return f->total_size;
 
    case FRAME_POINTER_REGNUM:
 
    case FRAME_POINTER_REGNUM:
 
      return 0;
 
      return 0;
 
    default:
 
    default:
 
      gcc_unreachable ();
 
      gcc_unreachable ();
 
    }
 
    }
 
}
 
}
 
 
 
 
 
/* Argument support functions.  */
 
/* Argument support functions.  */
 
 
 
 
 
/* Initialize CUMULATIVE_ARGS for a function.  */
 
/* Initialize CUMULATIVE_ARGS for a function.  */
 
void
 
void
 
score_init_cumulative_args (CUMULATIVE_ARGS *cum,
 
score_init_cumulative_args (CUMULATIVE_ARGS *cum,
 
                            tree fntype ATTRIBUTE_UNUSED,
 
                            tree fntype ATTRIBUTE_UNUSED,
 
                            rtx libname ATTRIBUTE_UNUSED)
 
                            rtx libname ATTRIBUTE_UNUSED)
 
{
 
{
 
  memset (cum, 0, sizeof (CUMULATIVE_ARGS));
 
  memset (cum, 0, sizeof (CUMULATIVE_ARGS));
 
}
 
}
 
 
 
 
 
/* Implement FUNCTION_ARG_ADVANCE macro.  */
 
/* Implement FUNCTION_ARG_ADVANCE macro.  */
 
void
 
void
 
score_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
 
score_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
 
                            tree type, int named)
 
                            tree type, int named)
 
{
 
{
 
  struct score_arg_info info;
 
  struct score_arg_info info;
 
  classify_arg (cum, mode, type, named, &info);
 
  classify_arg (cum, mode, type, named, &info);
 
  cum->num_gprs = info.reg_offset + info.reg_words;
 
  cum->num_gprs = info.reg_offset + info.reg_words;
 
  if (info.stack_words > 0)
 
  if (info.stack_words > 0)
 
    cum->stack_words = info.stack_offset + info.stack_words;
 
    cum->stack_words = info.stack_offset + info.stack_words;
 
  cum->arg_number++;
 
  cum->arg_number++;
 
}
 
}
 
 
 
 
 
/* Implement TARGET_ARG_PARTIAL_BYTES macro.  */
 
/* Implement TARGET_ARG_PARTIAL_BYTES macro.  */
 
static int
 
static int
 
score_arg_partial_bytes (const CUMULATIVE_ARGS *cum,
 
score_arg_partial_bytes (const CUMULATIVE_ARGS *cum,
 
                         enum machine_mode mode, tree type, int named)
 
                         enum machine_mode mode, tree type, int named)
 
{
 
{
 
  struct score_arg_info info;
 
  struct score_arg_info info;
 
  classify_arg (cum, mode, type, named, &info);
 
  classify_arg (cum, mode, type, named, &info);
 
  return info.stack_words > 0 ? info.reg_words * UNITS_PER_WORD : 0;
 
  return info.stack_words > 0 ? info.reg_words * UNITS_PER_WORD : 0;
 
}
 
}
 
 
 
 
 
/* Implement FUNCTION_ARG macro.  */
 
/* Implement FUNCTION_ARG macro.  */
 
rtx
 
rtx
 
score_function_arg (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
 
score_function_arg (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
 
                    tree type, int named)
 
                    tree type, int named)
 
{
 
{
 
  struct score_arg_info info;
 
  struct score_arg_info info;
 
 
 
 
 
  if (mode == VOIDmode || !named)
 
  if (mode == VOIDmode || !named)
 
    return 0;
 
    return 0;
 
 
 
 
 
  classify_arg (cum, mode, type, named, &info);
 
  classify_arg (cum, mode, type, named, &info);
 
 
 
 
 
  if (info.reg_offset == ARG_REG_NUM)
 
  if (info.reg_offset == ARG_REG_NUM)
 
    return 0;
 
    return 0;
 
 
 
 
 
  if (!info.stack_words)
 
  if (!info.stack_words)
 
    return gen_rtx_REG (mode, ARG_REG_FIRST + info.reg_offset);
 
    return gen_rtx_REG (mode, ARG_REG_FIRST + info.reg_offset);
 
  else
 
  else
 
    {
 
    {
 
      rtx ret = gen_rtx_PARALLEL (mode, rtvec_alloc (info.reg_words));
 
      rtx ret = gen_rtx_PARALLEL (mode, rtvec_alloc (info.reg_words));
 
      unsigned int i, part_offset = 0;
 
      unsigned int i, part_offset = 0;
 
      for (i = 0; i < info.reg_words; i++)
 
      for (i = 0; i < info.reg_words; i++)
 
        {
 
        {
 
          rtx reg;
 
          rtx reg;
 
          reg = gen_rtx_REG (SImode, ARG_REG_FIRST + info.reg_offset + i);
 
          reg = gen_rtx_REG (SImode, ARG_REG_FIRST + info.reg_offset + i);
 
          XVECEXP (ret, 0, i) = gen_rtx_EXPR_LIST (SImode, reg,
 
          XVECEXP (ret, 0, i) = gen_rtx_EXPR_LIST (SImode, reg,
 
                                                   GEN_INT (part_offset));
 
                                                   GEN_INT (part_offset));
 
          part_offset += UNITS_PER_WORD;
 
          part_offset += UNITS_PER_WORD;
 
        }
 
        }
 
      return ret;
 
      return ret;
 
    }
 
    }
 
}
 
}
 
 
 
 
 
/* Implement FUNCTION_VALUE and LIBCALL_VALUE.  For normal calls,
 
/* Implement FUNCTION_VALUE and LIBCALL_VALUE.  For normal calls,
 
   VALTYPE is the return type and MODE is VOIDmode.  For libcalls,
 
   VALTYPE is the return type and MODE is VOIDmode.  For libcalls,
 
   VALTYPE is null and MODE is the mode of the return value.  */
 
   VALTYPE is null and MODE is the mode of the return value.  */
 
rtx
 
rtx
 
score_function_value (tree valtype, tree func ATTRIBUTE_UNUSED,
 
score_function_value (tree valtype, tree func ATTRIBUTE_UNUSED,
 
                      enum machine_mode mode)
 
                      enum machine_mode mode)
 
{
 
{
 
  if (valtype)
 
  if (valtype)
 
    {
 
    {
 
      int unsignedp;
 
      int unsignedp;
 
      mode = TYPE_MODE (valtype);
 
      mode = TYPE_MODE (valtype);
 
      unsignedp = TYPE_UNSIGNED (valtype);
 
      unsignedp = TYPE_UNSIGNED (valtype);
 
      mode = promote_mode (valtype, mode, &unsignedp, 1);
 
      mode = promote_mode (valtype, mode, &unsignedp, 1);
 
    }
 
    }
 
  return gen_rtx_REG (mode, RT_REGNUM);
 
  return gen_rtx_REG (mode, RT_REGNUM);
 
}
 
}
 
 
 
 
 
/* Implement INITIALIZE_TRAMPOLINE macro.  */
 
/* Implement INITIALIZE_TRAMPOLINE macro.  */
 
void
 
void
 
score_initialize_trampoline (rtx ADDR, rtx FUNC, rtx CHAIN)
 
score_initialize_trampoline (rtx ADDR, rtx FUNC, rtx CHAIN)
 
{
 
{
 
#define FFCACHE          "_flush_cache"
 
#define FFCACHE          "_flush_cache"
 
#define CODE_SIZE        (TRAMPOLINE_INSNS * UNITS_PER_WORD)
 
#define CODE_SIZE        (TRAMPOLINE_INSNS * UNITS_PER_WORD)
 
 
 
 
 
  rtx pfunc, pchain;
 
  rtx pfunc, pchain;
 
 
 
 
 
  pfunc = plus_constant (ADDR, CODE_SIZE);
 
  pfunc = plus_constant (ADDR, CODE_SIZE);
 
  pchain = plus_constant (ADDR, CODE_SIZE + GET_MODE_SIZE (SImode));
 
  pchain = plus_constant (ADDR, CODE_SIZE + GET_MODE_SIZE (SImode));
 
 
 
 
 
  emit_move_insn (gen_rtx_MEM (SImode, pfunc), FUNC);
 
  emit_move_insn (gen_rtx_MEM (SImode, pfunc), FUNC);
 
  emit_move_insn (gen_rtx_MEM (SImode, pchain), CHAIN);
 
  emit_move_insn (gen_rtx_MEM (SImode, pchain), CHAIN);
 
  emit_library_call (gen_rtx_SYMBOL_REF (Pmode, FFCACHE),
 
  emit_library_call (gen_rtx_SYMBOL_REF (Pmode, FFCACHE),
 
                     0, VOIDmode, 2,
 
                     0, VOIDmode, 2,
 
                     ADDR, Pmode,
 
                     ADDR, Pmode,
 
                     GEN_INT (TRAMPOLINE_SIZE), SImode);
 
                     GEN_INT (TRAMPOLINE_SIZE), SImode);
 
#undef FFCACHE
 
#undef FFCACHE
 
#undef CODE_SIZE
 
#undef CODE_SIZE
 
}
 
}
 
 
 
 
 
/* This function is used to implement REG_MODE_OK_FOR_BASE_P macro.  */
 
/* This function is used to implement REG_MODE_OK_FOR_BASE_P macro.  */
 
int
 
int
 
score_regno_mode_ok_for_base_p (int regno, int strict)
 
score_regno_mode_ok_for_base_p (int regno, int strict)
 
{
 
{
 
  if (regno >= FIRST_PSEUDO_REGISTER)
 
  if (regno >= FIRST_PSEUDO_REGISTER)
 
    {
 
    {
 
      if (!strict)
 
      if (!strict)
 
        return 1;
 
        return 1;
 
      regno = reg_renumber[regno];
 
      regno = reg_renumber[regno];
 
    }
 
    }
 
  if (regno == ARG_POINTER_REGNUM
 
  if (regno == ARG_POINTER_REGNUM
 
      || regno == FRAME_POINTER_REGNUM)
 
      || regno == FRAME_POINTER_REGNUM)
 
    return 1;
 
    return 1;
 
  return GP_REG_P (regno);
 
  return GP_REG_P (regno);
 
}
 
}
 
 
 
 
 
/* Implement GO_IF_LEGITIMATE_ADDRESS macro.  */
 
/* Implement GO_IF_LEGITIMATE_ADDRESS macro.  */
 
int
 
int
 
score_address_p (enum machine_mode mode, rtx x, int strict)
 
score_address_p (enum machine_mode mode, rtx x, int strict)
 
{
 
{
 
  struct score_address_info addr;
 
  struct score_address_info addr;
 
 
 
 
 
  return mda_classify_address (&addr, mode, x, strict);
 
  return mda_classify_address (&addr, mode, x, strict);
 
}
 
}
 
 
 
 
 
/* Copy VALUE to a register and return that register.  If new psuedos
 
/* Copy VALUE to a register and return that register.  If new psuedos
 
   are allowed, copy it into a new register, otherwise use DEST.  */
 
   are allowed, copy it into a new register, otherwise use DEST.  */
 
static rtx
 
static rtx
 
score_force_temporary (rtx dest, rtx value)
 
score_force_temporary (rtx dest, rtx value)
 
{
 
{
 
  if (!no_new_pseudos)
 
  if (!no_new_pseudos)
 
    return force_reg (Pmode, value);
 
    return force_reg (Pmode, value);
 
  else
 
  else
 
    {
 
    {
 
      emit_move_insn (copy_rtx (dest), value);
 
      emit_move_insn (copy_rtx (dest), value);
 
      return dest;
 
      return dest;
 
    }
 
    }
 
}
 
}
 
 
 
 
 
/* Return a LO_SUM expression for ADDR.  TEMP is as for score_force_temporary
 
/* Return a LO_SUM expression for ADDR.  TEMP is as for score_force_temporary
 
   and is used to load the high part into a register.  */
 
   and is used to load the high part into a register.  */
 
static rtx
 
static rtx
 
score_split_symbol (rtx temp, rtx addr)
 
score_split_symbol (rtx temp, rtx addr)
 
{
 
{
 
  rtx high = score_force_temporary (temp,
 
  rtx high = score_force_temporary (temp,
 
                                    gen_rtx_HIGH (Pmode, copy_rtx (addr)));
 
                                    gen_rtx_HIGH (Pmode, copy_rtx (addr)));
 
  return gen_rtx_LO_SUM (Pmode, high, addr);
 
  return gen_rtx_LO_SUM (Pmode, high, addr);
 
}
 
}
 
 
 
 
 
/* This function is used to implement LEGITIMIZE_ADDRESS.  If *XLOC can
 
/* This function is used to implement LEGITIMIZE_ADDRESS.  If *XLOC can
 
   be legitimized in a way that the generic machinery might not expect,
 
   be legitimized in a way that the generic machinery might not expect,
 
   put the new address in *XLOC and return true.  */
 
   put the new address in *XLOC and return true.  */
 
int
 
int
 
score_legitimize_address (rtx *xloc)
 
score_legitimize_address (rtx *xloc)
 
{
 
{
 
  enum score_symbol_type symbol_type;
 
  enum score_symbol_type symbol_type;
 
 
 
 
 
  if (mda_symbolic_constant_p (*xloc, &symbol_type)
 
  if (mda_symbolic_constant_p (*xloc, &symbol_type)
 
      && symbol_type == SYMBOL_GENERAL)
 
      && symbol_type == SYMBOL_GENERAL)
 
    {
 
    {
 
      *xloc = score_split_symbol (0, *xloc);
 
      *xloc = score_split_symbol (0, *xloc);
 
      return 1;
 
      return 1;
 
    }
 
    }
 
 
 
 
 
  if (GET_CODE (*xloc) == PLUS
 
  if (GET_CODE (*xloc) == PLUS
 
      && GET_CODE (XEXP (*xloc, 1)) == CONST_INT)
 
      && GET_CODE (XEXP (*xloc, 1)) == CONST_INT)
 
    {
 
    {
 
      rtx reg = XEXP (*xloc, 0);
 
      rtx reg = XEXP (*xloc, 0);
 
      if (!mda_valid_base_register_p (reg, 0))
 
      if (!mda_valid_base_register_p (reg, 0))
 
        reg = copy_to_mode_reg (Pmode, reg);
 
        reg = copy_to_mode_reg (Pmode, reg);
 
      *xloc = score_add_offset (NULL, reg, INTVAL (XEXP (*xloc, 1)));
 
      *xloc = score_add_offset (NULL, reg, INTVAL (XEXP (*xloc, 1)));
 
      return 1;
 
      return 1;
 
    }
 
    }
 
  return 0;
 
  return 0;
 
}
 
}
 
 
 
 
 
/* Return a number assessing the cost of moving a register in class
 
/* Return a number assessing the cost of moving a register in class
 
   FROM to class TO. */
 
   FROM to class TO. */
 
int
 
int
 
score_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
 
score_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
 
                          enum reg_class from, enum reg_class to)
 
                          enum reg_class from, enum reg_class to)
 
{
 
{
 
  if (GR_REG_CLASS_P (from))
 
  if (GR_REG_CLASS_P (from))
 
    {
 
    {
 
      if (GR_REG_CLASS_P (to))
 
      if (GR_REG_CLASS_P (to))
 
        return 2;
 
        return 2;
 
      else if (SP_REG_CLASS_P (to))
 
      else if (SP_REG_CLASS_P (to))
 
        return 4;
 
        return 4;
 
      else if (CP_REG_CLASS_P (to))
 
      else if (CP_REG_CLASS_P (to))
 
        return 5;
 
        return 5;
 
      else if (CE_REG_CLASS_P (to))
 
      else if (CE_REG_CLASS_P (to))
 
        return 6;
 
        return 6;
 
    }
 
    }
 
  if (GR_REG_CLASS_P (to))
 
  if (GR_REG_CLASS_P (to))
 
    {
 
    {
 
      if (GR_REG_CLASS_P (from))
 
      if (GR_REG_CLASS_P (from))
 
        return 2;
 
        return 2;
 
      else if (SP_REG_CLASS_P (from))
 
      else if (SP_REG_CLASS_P (from))
 
        return 4;
 
        return 4;
 
      else if (CP_REG_CLASS_P (from))
 
      else if (CP_REG_CLASS_P (from))
 
        return 5;
 
        return 5;
 
      else if (CE_REG_CLASS_P (from))
 
      else if (CE_REG_CLASS_P (from))
 
        return 6;
 
        return 6;
 
    }
 
    }
 
  return 12;
 
  return 12;
 
}
 
}
 
 
 
 
 
/* Return the number of instructions needed to load a symbol of the
 
/* Return the number of instructions needed to load a symbol of the
 
   given type into a register.  */
 
   given type into a register.  */
 
static int
 
static int
 
score_symbol_insns (enum score_symbol_type type)
 
score_symbol_insns (enum score_symbol_type type)
 
{
 
{
 
  switch (type)
 
  switch (type)
 
    {
 
    {
 
    case SYMBOL_GENERAL:
 
    case SYMBOL_GENERAL:
 
      return 2;
 
      return 2;
 
 
 
 
 
    case SYMBOL_SMALL_DATA:
 
    case SYMBOL_SMALL_DATA:
 
      return 1;
 
      return 1;
 
    }
 
    }
 
 
 
 
 
  gcc_unreachable ();
 
  gcc_unreachable ();
 
}
 
}
 
 
 
 
 
/* Return the number of instructions needed to load or store a value
 
/* Return the number of instructions needed to load or store a value
 
   of mode MODE at X.  Return 0 if X isn't valid for MODE.  */
 
   of mode MODE at X.  Return 0 if X isn't valid for MODE.  */
 
static int
 
static int
 
score_address_insns (rtx x, enum machine_mode mode)
 
score_address_insns (rtx x, enum machine_mode mode)
 
{
 
{
 
  struct score_address_info addr;
 
  struct score_address_info addr;
 
  int factor;
 
  int factor;
 
 
 
 
 
  if (mode == BLKmode)
 
  if (mode == BLKmode)
 
    factor = 1;
 
    factor = 1;
 
  else
 
  else
 
    factor = (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
 
    factor = (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
 
 
 
 
 
  if (mda_classify_address (&addr, mode, x, false))
 
  if (mda_classify_address (&addr, mode, x, false))
 
    switch (addr.type)
 
    switch (addr.type)
 
      {
 
      {
 
      case ADD_REG:
 
      case ADD_REG:
 
      case ADD_CONST_INT:
 
      case ADD_CONST_INT:
 
        return factor;
 
        return factor;
 
 
 
 
 
      case ADD_SYMBOLIC:
 
      case ADD_SYMBOLIC:
 
        return factor * score_symbol_insns (addr.symbol_type);
 
        return factor * score_symbol_insns (addr.symbol_type);
 
      }
 
      }
 
  return 0;
 
  return 0;
 
}
 
}
 
 
 
 
 
/* Implement TARGET_RTX_COSTS macro.  */
 
/* Implement TARGET_RTX_COSTS macro.  */
 
static bool
 
static bool
 
score_rtx_costs (rtx x, enum rtx_code code, enum rtx_code outer_code,
 
score_rtx_costs (rtx x, enum rtx_code code, enum rtx_code outer_code,
 
                 int *total)
 
                 int *total)
 
{
 
{
 
  enum machine_mode mode = GET_MODE (x);
 
  enum machine_mode mode = GET_MODE (x);
 
 
 
 
 
  switch (code)
 
  switch (code)
 
    {
 
    {
 
    case CONST_INT:
 
    case CONST_INT:
 
      if (outer_code == SET)
 
      if (outer_code == SET)
 
        {
 
        {
 
          if (CONST_OK_FOR_LETTER_P (INTVAL (x), 'I')
 
          if (CONST_OK_FOR_LETTER_P (INTVAL (x), 'I')
 
              || CONST_OK_FOR_LETTER_P (INTVAL (x), 'L'))
 
              || CONST_OK_FOR_LETTER_P (INTVAL (x), 'L'))
 
            *total = COSTS_N_INSNS (1);
 
            *total = COSTS_N_INSNS (1);
 
          else
 
          else
 
            *total = COSTS_N_INSNS (2);
 
            *total = COSTS_N_INSNS (2);
 
        }
 
        }
 
      else if (outer_code == PLUS || outer_code == MINUS)
 
      else if (outer_code == PLUS || outer_code == MINUS)
 
        {
 
        {
 
          if (CONST_OK_FOR_LETTER_P (INTVAL (x), 'N'))
 
          if (CONST_OK_FOR_LETTER_P (INTVAL (x), 'N'))
 
            *total = 0;
 
            *total = 0;
 
          else if (CONST_OK_FOR_LETTER_P (INTVAL (x), 'I')
 
          else if (CONST_OK_FOR_LETTER_P (INTVAL (x), 'I')
 
                   || CONST_OK_FOR_LETTER_P (INTVAL (x), 'L'))
 
                   || CONST_OK_FOR_LETTER_P (INTVAL (x), 'L'))
 
            *total = 1;
 
            *total = 1;
 
          else
 
          else
 
            *total = COSTS_N_INSNS (2);
 
            *total = COSTS_N_INSNS (2);
 
        }
 
        }
 
      else if (outer_code == AND || outer_code == IOR)
 
      else if (outer_code == AND || outer_code == IOR)
 
        {
 
        {
 
          if (CONST_OK_FOR_LETTER_P (INTVAL (x), 'M'))
 
          if (CONST_OK_FOR_LETTER_P (INTVAL (x), 'M'))
 
            *total = 0;
 
            *total = 0;
 
          else if (CONST_OK_FOR_LETTER_P (INTVAL (x), 'I')
 
          else if (CONST_OK_FOR_LETTER_P (INTVAL (x), 'I')
 
                   || CONST_OK_FOR_LETTER_P (INTVAL (x), 'K'))
 
                   || CONST_OK_FOR_LETTER_P (INTVAL (x), 'K'))
 
            *total = 1;
 
            *total = 1;
 
          else
 
          else
 
            *total = COSTS_N_INSNS (2);
 
            *total = COSTS_N_INSNS (2);
 
        }
 
        }
 
      else
 
      else
 
        {
 
        {
 
          *total = 0;
 
          *total = 0;
 
        }
 
        }
 
      return true;
 
      return true;
 
 
 
 
 
    case CONST:
 
    case CONST:
 
    case SYMBOL_REF:
 
    case SYMBOL_REF:
 
    case LABEL_REF:
 
    case LABEL_REF:
 
    case CONST_DOUBLE:
 
    case CONST_DOUBLE:
 
      *total = COSTS_N_INSNS (2);
 
      *total = COSTS_N_INSNS (2);
 
      return true;
 
      return true;
 
 
 
 
 
    case MEM:
 
    case MEM:
 
      {
 
      {
 
        /* If the address is legitimate, return the number of
 
        /* If the address is legitimate, return the number of
 
           instructions it needs, otherwise use the default handling.  */
 
           instructions it needs, otherwise use the default handling.  */
 
        int n = score_address_insns (XEXP (x, 0), GET_MODE (x));
 
        int n = score_address_insns (XEXP (x, 0), GET_MODE (x));
 
        if (n > 0)
 
        if (n > 0)
 
          {
 
          {
 
            *total = COSTS_N_INSNS (n + 1);
 
            *total = COSTS_N_INSNS (n + 1);
 
            return true;
 
            return true;
 
          }
 
          }
 
        return false;
 
        return false;
 
      }
 
      }
 
 
 
 
 
    case FFS:
 
    case FFS:
 
      *total = COSTS_N_INSNS (6);
 
      *total = COSTS_N_INSNS (6);
 
      return true;
 
      return true;
 
 
 
 
 
    case NOT:
 
    case NOT:
 
      *total = COSTS_N_INSNS (1);
 
      *total = COSTS_N_INSNS (1);
 
      return true;
 
      return true;
 
 
 
 
 
    case AND:
 
    case AND:
 
    case IOR:
 
    case IOR:
 
    case XOR:
 
    case XOR:
 
      if (mode == DImode)
 
      if (mode == DImode)
 
        {
 
        {
 
          *total = COSTS_N_INSNS (2);
 
          *total = COSTS_N_INSNS (2);
 
          return true;
 
          return true;
 
        }
 
        }
 
      return false;
 
      return false;
 
 
 
 
 
    case ASHIFT:
 
    case ASHIFT:
 
    case ASHIFTRT:
 
    case ASHIFTRT:
 
    case LSHIFTRT:
 
    case LSHIFTRT:
 
      if (mode == DImode)
 
      if (mode == DImode)
 
        {
 
        {
 
          *total = COSTS_N_INSNS ((GET_CODE (XEXP (x, 1)) == CONST_INT)
 
          *total = COSTS_N_INSNS ((GET_CODE (XEXP (x, 1)) == CONST_INT)
 
                                  ? 4 : 12);
 
                                  ? 4 : 12);
 
          return true;
 
          return true;
 
        }
 
        }
 
      return false;
 
      return false;
 
 
 
 
 
    case ABS:
 
    case ABS:
 
      *total = COSTS_N_INSNS (4);
 
      *total = COSTS_N_INSNS (4);
 
      return true;
 
      return true;
 
 
 
 
 
    case PLUS:
 
    case PLUS:
 
    case MINUS:
 
    case MINUS:
 
      if (mode == DImode)
 
      if (mode == DImode)
 
        {
 
        {
 
          *total = COSTS_N_INSNS (4);
 
          *total = COSTS_N_INSNS (4);
 
          return true;
 
          return true;
 
        }
 
        }
 
      *total = COSTS_N_INSNS (1);
 
      *total = COSTS_N_INSNS (1);
 
      return true;
 
      return true;
 
 
 
 
 
    case NEG:
 
    case NEG:
 
      if (mode == DImode)
 
      if (mode == DImode)
 
        {
 
        {
 
          *total = COSTS_N_INSNS (4);
 
          *total = COSTS_N_INSNS (4);
 
          return true;
 
          return true;
 
        }
 
        }
 
      return false;
 
      return false;
 
 
 
 
 
    case MULT:
 
    case MULT:
 
      *total = optimize_size ? COSTS_N_INSNS (2) : COSTS_N_INSNS (12);
 
      *total = optimize_size ? COSTS_N_INSNS (2) : COSTS_N_INSNS (12);
 
      return true;
 
      return true;
 
 
 
 
 
    case DIV:
 
    case DIV:
 
    case MOD:
 
    case MOD:
 
    case UDIV:
 
    case UDIV:
 
    case UMOD:
 
    case UMOD:
 
      *total = optimize_size ? COSTS_N_INSNS (2) : COSTS_N_INSNS (33);
 
      *total = optimize_size ? COSTS_N_INSNS (2) : COSTS_N_INSNS (33);
 
      return true;
 
      return true;
 
 
 
 
 
    case SIGN_EXTEND:
 
    case SIGN_EXTEND:
 
    case ZERO_EXTEND:
 
    case ZERO_EXTEND:
 
      switch (GET_MODE (XEXP (x, 0)))
 
      switch (GET_MODE (XEXP (x, 0)))
 
        {
 
        {
 
        case QImode:
 
        case QImode:
 
        case HImode:
 
        case HImode:
 
          if (GET_CODE (XEXP (x, 0)) == MEM)
 
          if (GET_CODE (XEXP (x, 0)) == MEM)
 
            {
 
            {
 
              *total = COSTS_N_INSNS (2);
 
              *total = COSTS_N_INSNS (2);
 
 
 
 
 
              if (!TARGET_LITTLE_ENDIAN &&
 
              if (!TARGET_LITTLE_ENDIAN &&
 
                  side_effects_p (XEXP (XEXP (x, 0), 0)))
 
                  side_effects_p (XEXP (XEXP (x, 0), 0)))
 
                *total = 100;
 
                *total = 100;
 
            }
 
            }
 
          else
 
          else
 
            *total = COSTS_N_INSNS (1);
 
            *total = COSTS_N_INSNS (1);
 
          break;
 
          break;
 
 
 
 
 
        default:
 
        default:
 
          *total = COSTS_N_INSNS (1);
 
          *total = COSTS_N_INSNS (1);
 
          break;
 
          break;
 
        }
 
        }
 
      return true;
 
      return true;
 
 
 
 
 
    default:
 
    default:
 
      return false;
 
      return false;
 
    }
 
    }
 
}
 
}
 
 
 
 
 
/* Implement TARGET_ADDRESS_COST macro.  */
 
/* Implement TARGET_ADDRESS_COST macro.  */
 
int
 
int
 
score_address_cost (rtx addr)
 
score_address_cost (rtx addr)
 
{
 
{
 
  return score_address_insns (addr, SImode);
 
  return score_address_insns (addr, SImode);
 
}
 
}
 
 
 
 
 
/* Implement ASM_OUTPUT_EXTERNAL macro.  */
 
/* Implement ASM_OUTPUT_EXTERNAL macro.  */
 
int
 
int
 
score_output_external (FILE *file ATTRIBUTE_UNUSED,
 
score_output_external (FILE *file ATTRIBUTE_UNUSED,
 
                       tree decl, const char *name)
 
                       tree decl, const char *name)
 
{
 
{
 
  register struct extern_list *p;
 
  register struct extern_list *p;
 
 
 
 
 
  if (th_in_small_data_p (decl))
 
  if (th_in_small_data_p (decl))
 
    {
 
    {
 
      p = (struct extern_list *) ggc_alloc (sizeof (struct extern_list));
 
      p = (struct extern_list *) ggc_alloc (sizeof (struct extern_list));
 
      p->next = extern_head;
 
      p->next = extern_head;
 
      p->name = name;
 
      p->name = name;
 
      p->size = int_size_in_bytes (TREE_TYPE (decl));
 
      p->size = int_size_in_bytes (TREE_TYPE (decl));
 
      extern_head = p;
 
      extern_head = p;
 
    }
 
    }
 
  return 0;
 
  return 0;
 
}
 
}
 
 
 
 
 
/* Output format asm string.  */
 
/* Output format asm string.  */
 
void
 
void
 
score_declare_object (FILE *stream, const char *name,
 
score_declare_object (FILE *stream, const char *name,
 
                      const char *directive, const char *fmt, ...)
 
                      const char *directive, const char *fmt, ...)
 
{
 
{
 
  va_list ap;
 
  va_list ap;
 
  fputs (directive, stream);
 
  fputs (directive, stream);
 
  assemble_name (stream, name);
 
  assemble_name (stream, name);
 
  va_start (ap, fmt);
 
  va_start (ap, fmt);
 
  vfprintf (stream, fmt, ap);
 
  vfprintf (stream, fmt, ap);
 
  va_end (ap);
 
  va_end (ap);
 
}
 
}
 
 
 
 
 
/* Implement RETURN_ADDR_RTX.  Note, we do not support moving
 
/* Implement RETURN_ADDR_RTX.  Note, we do not support moving
 
   back to a previous frame.  */
 
   back to a previous frame.  */
 
rtx
 
rtx
 
score_return_addr (int count, rtx frame ATTRIBUTE_UNUSED)
 
score_return_addr (int count, rtx frame ATTRIBUTE_UNUSED)
 
{
 
{
 
  if (count != 0)
 
  if (count != 0)
 
    return const0_rtx;
 
    return const0_rtx;
 
  return get_hard_reg_initial_val (Pmode, RA_REGNUM);
 
  return get_hard_reg_initial_val (Pmode, RA_REGNUM);
 
}
 
}
 
 
 
 
 
/* Implement PRINT_OPERAND macro.  */
 
/* Implement PRINT_OPERAND macro.  */
 
/* Score-specific operand codes:
 
/* Score-specific operand codes:
 
   '['        print .set nor1 directive
 
   '['        print .set nor1 directive
 
   ']'        print .set r1 directive
 
   ']'        print .set r1 directive
 
   'U'        print hi part of a CONST_INT rtx
 
   'U'        print hi part of a CONST_INT rtx
 
   'E'        print log2(v)
 
   'E'        print log2(v)
 
   'F'        print log2(~v)
 
   'F'        print log2(~v)
 
   'D'        print SFmode const double
 
   'D'        print SFmode const double
 
   'S'        selectively print "!" if operand is 15bit instruction accessible
 
   'S'        selectively print "!" if operand is 15bit instruction accessible
 
   'V'        print "v!" if operand is 15bit instruction accessible, or "lfh!"
 
   'V'        print "v!" if operand is 15bit instruction accessible, or "lfh!"
 
   'L'        low  part of DImode reg operand
 
   'L'        low  part of DImode reg operand
 
   'H'        high part of DImode reg operand
 
   'H'        high part of DImode reg operand
 
   'C'        print part of opcode for a branch condition.  */
 
   'C'        print part of opcode for a branch condition.  */
 
void
 
void
 
score_print_operand (FILE *file, rtx op, int c)
 
score_print_operand (FILE *file, rtx op, int c)
 
{
 
{
 
  enum rtx_code code = -1;
 
  enum rtx_code code = -1;
 
  if (!PRINT_OPERAND_PUNCT_VALID_P (c))
 
  if (!PRINT_OPERAND_PUNCT_VALID_P (c))
 
    code = GET_CODE (op);
 
    code = GET_CODE (op);
 
 
 
 
 
  if (c == '[')
 
  if (c == '[')
 
    {
 
    {
 
      fprintf (file, ".set r1\n");
 
      fprintf (file, ".set r1\n");
 
    }
 
    }
 
  else if (c == ']')
 
  else if (c == ']')
 
    {
 
    {
 
      fprintf (file, "\n\t.set nor1");
 
      fprintf (file, "\n\t.set nor1");
 
    }
 
    }
 
  else if (c == 'U')
 
  else if (c == 'U')
 
    {
 
    {
 
      gcc_assert (code == CONST_INT);
 
      gcc_assert (code == CONST_INT);
 
      fprintf (file, HOST_WIDE_INT_PRINT_HEX,
 
      fprintf (file, HOST_WIDE_INT_PRINT_HEX,
 
               (INTVAL (op) >> 16) & 0xffff);
 
               (INTVAL (op) >> 16) & 0xffff);
 
    }
 
    }
 
  else if (c == 'D')
 
  else if (c == 'D')
 
    {
 
    {
 
      if (GET_CODE (op) == CONST_DOUBLE)
 
      if (GET_CODE (op) == CONST_DOUBLE)
 
        {
 
        {
 
          rtx temp = gen_lowpart (SImode, op);
 
          rtx temp = gen_lowpart (SImode, op);
 
          gcc_assert (GET_MODE (op) == SFmode);
 
          gcc_assert (GET_MODE (op) == SFmode);
 
          fprintf (file, HOST_WIDE_INT_PRINT_HEX, INTVAL (temp) & 0xffffffff);
 
          fprintf (file, HOST_WIDE_INT_PRINT_HEX, INTVAL (temp) & 0xffffffff);
 
        }
 
        }
 
      else
 
      else
 
        output_addr_const (file, op);
 
        output_addr_const (file, op);
 
    }
 
    }
 
  else if (c == 'S')
 
  else if (c == 'S')
 
    {
 
    {
 
      gcc_assert (code == REG);
 
      gcc_assert (code == REG);
 
      if (G16_REG_P (REGNO (op)))
 
      if (G16_REG_P (REGNO (op)))
 
        fprintf (file, "!");
 
        fprintf (file, "!");
 
    }
 
    }
 
  else if (c == 'V')
 
  else if (c == 'V')
 
    {
 
    {
 
      gcc_assert (code == REG);
 
      gcc_assert (code == REG);
 
      fprintf (file, G16_REG_P (REGNO (op)) ? "v!" : "lfh!");
 
      fprintf (file, G16_REG_P (REGNO (op)) ? "v!" : "lfh!");
 
    }
 
    }
 
  else if (c == 'C')
 
  else if (c == 'C')
 
    {
 
    {
 
      enum machine_mode mode = GET_MODE (XEXP (op, 0));
 
      enum machine_mode mode = GET_MODE (XEXP (op, 0));
 
 
 
 
 
      switch (code)
 
      switch (code)
 
        {
 
        {
 
        case EQ: fputs ("eq", file); break;
 
        case EQ: fputs ("eq", file); break;
 
        case NE: fputs ("ne", file); break;
 
        case NE: fputs ("ne", file); break;
 
        case GT: fputs ("gt", file); break;
 
        case GT: fputs ("gt", file); break;
 
        case GE: fputs (mode != CCmode ? "pl" : "ge", file); break;
 
        case GE: fputs (mode != CCmode ? "pl" : "ge", file); break;
 
        case LT: fputs (mode != CCmode ? "mi" : "lt", file); break;
 
        case LT: fputs (mode != CCmode ? "mi" : "lt", file); break;
 
        case LE: fputs ("le", file); break;
 
        case LE: fputs ("le", file); break;
 
        case GTU: fputs ("gtu", file); break;
 
        case GTU: fputs ("gtu", file); break;
 
        case GEU: fputs ("cs", file); break;
 
        case GEU: fputs ("cs", file); break;
 
        case LTU: fputs ("cc", file); break;
 
        case LTU: fputs ("cc", file); break;
 
        case LEU: fputs ("leu", file); break;
 
        case LEU: fputs ("leu", file); break;
 
        default:
 
        default:
 
          output_operand_lossage ("invalid operand for code: '%c'", code);
 
          output_operand_lossage ("invalid operand for code: '%c'", code);
 
        }
 
        }
 
    }
 
    }
 
  else if (c == 'E')
 
  else if (c == 'E')
 
    {
 
    {
 
      unsigned HOST_WIDE_INT i;
 
      unsigned HOST_WIDE_INT i;
 
      unsigned HOST_WIDE_INT pow2mask = 1;
 
      unsigned HOST_WIDE_INT pow2mask = 1;
 
      unsigned HOST_WIDE_INT val;
 
      unsigned HOST_WIDE_INT val;
 
 
 
 
 
      val = INTVAL (op);
 
      val = INTVAL (op);
 
      for (i = 0; i < 32; i++)
 
      for (i = 0; i < 32; i++)
 
        {
 
        {
 
          if (val == pow2mask)
 
          if (val == pow2mask)
 
            break;
 
            break;
 
          pow2mask <<= 1;
 
          pow2mask <<= 1;
 
        }
 
        }
 
      gcc_assert (i < 32);
 
      gcc_assert (i < 32);
 
      fprintf (file, HOST_WIDE_INT_PRINT_HEX, i);
 
      fprintf (file, HOST_WIDE_INT_PRINT_HEX, i);
 
    }
 
    }
 
  else if (c == 'F')
 
  else if (c == 'F')
 
    {
 
    {
 
      unsigned HOST_WIDE_INT i;
 
      unsigned HOST_WIDE_INT i;
 
      unsigned HOST_WIDE_INT pow2mask = 1;
 
      unsigned HOST_WIDE_INT pow2mask = 1;
 
      unsigned HOST_WIDE_INT val;
 
      unsigned HOST_WIDE_INT val;
 
 
 
 
 
      val = ~INTVAL (op);
 
      val = ~INTVAL (op);
 
      for (i = 0; i < 32; i++)
 
      for (i = 0; i < 32; i++)
 
        {
 
        {
 
          if (val == pow2mask)
 
          if (val == pow2mask)
 
            break;
 
            break;
 
          pow2mask <<= 1;
 
          pow2mask <<= 1;
 
        }
 
        }
 
      gcc_assert (i < 32);
 
      gcc_assert (i < 32);
 
      fprintf (file, HOST_WIDE_INT_PRINT_HEX, i);
 
      fprintf (file, HOST_WIDE_INT_PRINT_HEX, i);
 
    }
 
    }
 
  else if (code == REG)
 
  else if (code == REG)
 
    {
 
    {
 
      int regnum = REGNO (op);
 
      int regnum = REGNO (op);
 
      if ((c == 'H' && !WORDS_BIG_ENDIAN)
 
      if ((c == 'H' && !WORDS_BIG_ENDIAN)
 
          || (c == 'L' && WORDS_BIG_ENDIAN))
 
          || (c == 'L' && WORDS_BIG_ENDIAN))
 
        regnum ++;
 
        regnum ++;
 
      fprintf (file, "%s", reg_names[regnum]);
 
      fprintf (file, "%s", reg_names[regnum]);
 
    }
 
    }
 
  else
 
  else
 
    {
 
    {
 
      switch (code)
 
      switch (code)
 
        {
 
        {
 
        case MEM:
 
        case MEM:
 
          score_print_operand_address (file, op);
 
          score_print_operand_address (file, op);
 
          break;
 
          break;
 
        default:
 
        default:
 
          output_addr_const (file, op);
 
          output_addr_const (file, op);
 
        }
 
        }
 
    }
 
    }
 
}
 
}
 
 
 
 
 
/* Implement PRINT_OPERAND_ADDRESS macro.  */
 
/* Implement PRINT_OPERAND_ADDRESS macro.  */
 
void
 
void
 
score_print_operand_address (FILE *file, rtx x)
 
score_print_operand_address (FILE *file, rtx x)
 
{
 
{
 
  struct score_address_info addr;
 
  struct score_address_info addr;
 
  enum rtx_code code = GET_CODE (x);
 
  enum rtx_code code = GET_CODE (x);
 
  enum machine_mode mode = GET_MODE (x);
 
  enum machine_mode mode = GET_MODE (x);
 
 
 
 
 
  if (code == MEM)
 
  if (code == MEM)
 
    x = XEXP (x, 0);
 
    x = XEXP (x, 0);
 
 
 
 
 
  if (mda_classify_address (&addr, mode, x, true))
 
  if (mda_classify_address (&addr, mode, x, true))
 
    {
 
    {
 
      switch (addr.type)
 
      switch (addr.type)
 
        {
 
        {
 
        case ADD_REG:
 
        case ADD_REG:
 
          {
 
          {
 
            switch (addr.code)
 
            switch (addr.code)
 
              {
 
              {
 
              case PRE_DEC:
 
              case PRE_DEC:
 
                fprintf (file, "[%s,-%ld]+", reg_names[REGNO (addr.reg)],
 
                fprintf (file, "[%s,-%ld]+", reg_names[REGNO (addr.reg)],
 
                         INTVAL (addr.offset));
 
                         INTVAL (addr.offset));
 
                break;
 
                break;
 
              case POST_DEC:
 
              case POST_DEC:
 
                fprintf (file, "[%s]+,-%ld", reg_names[REGNO (addr.reg)],
 
                fprintf (file, "[%s]+,-%ld", reg_names[REGNO (addr.reg)],
 
                         INTVAL (addr.offset));
 
                         INTVAL (addr.offset));
 
                break;
 
                break;
 
              case PRE_INC:
 
              case PRE_INC:
 
                fprintf (file, "[%s, %ld]+", reg_names[REGNO (addr.reg)],
 
                fprintf (file, "[%s, %ld]+", reg_names[REGNO (addr.reg)],
 
                         INTVAL (addr.offset));
 
                         INTVAL (addr.offset));
 
                break;
 
                break;
 
              case POST_INC:
 
              case POST_INC:
 
                fprintf (file, "[%s]+, %ld", reg_names[REGNO (addr.reg)],
 
                fprintf (file, "[%s]+, %ld", reg_names[REGNO (addr.reg)],
 
                         INTVAL (addr.offset));
 
                         INTVAL (addr.offset));
 
                break;
 
                break;
 
              default:
 
              default:
 
                if (INTVAL(addr.offset) == 0)
 
                if (INTVAL(addr.offset) == 0)
 
                  fprintf(file, "[%s]", reg_names[REGNO (addr.reg)]);
 
                  fprintf(file, "[%s]", reg_names[REGNO (addr.reg)]);
 
                else
 
                else
 
                  fprintf(file, "[%s, %ld]", reg_names[REGNO (addr.reg)],
 
                  fprintf(file, "[%s, %ld]", reg_names[REGNO (addr.reg)],
 
                          INTVAL(addr.offset));
 
                          INTVAL(addr.offset));
 
                break;
 
                break;
 
              }
 
              }
 
          }
 
          }
 
          return;
 
          return;
 
        case ADD_CONST_INT:
 
        case ADD_CONST_INT:
 
        case ADD_SYMBOLIC:
 
        case ADD_SYMBOLIC:
 
          output_addr_const (file, x);
 
          output_addr_const (file, x);
 
          return;
 
          return;
 
        }
 
        }
 
    }
 
    }
 
  print_rtl (stderr, x);
 
  print_rtl (stderr, x);
 
  gcc_unreachable ();
 
  gcc_unreachable ();
 
}
 
}
 
 
 
 
 
/* Implement SELECT_CC_MODE macro.  */
 
/* Implement SELECT_CC_MODE macro.  */
 
enum machine_mode
 
enum machine_mode
 
score_select_cc_mode (enum rtx_code op, rtx x, rtx y)
 
score_select_cc_mode (enum rtx_code op, rtx x, rtx y)
 
{
 
{
 
  if ((op == EQ || op == NE || op == LT || op == GE)
 
  if ((op == EQ || op == NE || op == LT || op == GE)
 
      && y == const0_rtx
 
      && y == const0_rtx
 
      && GET_MODE (x) == SImode)
 
      && GET_MODE (x) == SImode)
 
    {
 
    {
 
      switch (GET_CODE (x))
 
      switch (GET_CODE (x))
 
        {
 
        {
 
        case PLUS:
 
        case PLUS:
 
        case MINUS:
 
        case MINUS:
 
        case NEG:
 
        case NEG:
 
        case AND:
 
        case AND:
 
        case IOR:
 
        case IOR:
 
        case XOR:
 
        case XOR:
 
        case NOT:
 
        case NOT:
 
        case ASHIFT:
 
        case ASHIFT:
 
        case LSHIFTRT:
 
        case LSHIFTRT:
 
        case ASHIFTRT:
 
        case ASHIFTRT:
 
          return CC_NZmode;
 
          return CC_NZmode;
 
 
 
 
 
        case SIGN_EXTEND:
 
        case SIGN_EXTEND:
 
        case ZERO_EXTEND:
 
        case ZERO_EXTEND:
 
        case ROTATE:
 
        case ROTATE:
 
        case ROTATERT:
 
        case ROTATERT:
 
          return (op == LT || op == GE) ? CC_Nmode : CCmode;
 
          return (op == LT || op == GE) ? CC_Nmode : CCmode;
 
 
 
 
 
        default:
 
        default:
 
          return CCmode;
 
          return CCmode;
 
        }
 
        }
 
    }
 
    }
 
 
 
 
 
  if ((op == EQ || op == NE)
 
  if ((op == EQ || op == NE)
 
      && (GET_CODE (y) == NEG)
 
      && (GET_CODE (y) == NEG)
 
      && register_operand (XEXP (y, 0), SImode)
 
      && register_operand (XEXP (y, 0), SImode)
 
      && register_operand (x, SImode))
 
      && register_operand (x, SImode))
 
    {
 
    {
 
      return CC_NZmode;
 
      return CC_NZmode;
 
    }
 
    }
 
 
 
 
 
  return CCmode;
 
  return CCmode;
 
}
 
}
 
 
 
 
 
struct gcc_target targetm = TARGET_INITIALIZER;
 
struct gcc_target targetm = TARGET_INITIALIZER;
 
 
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.