Subversion Repositories openrisc

/* score-mdaux.h for Sunplus S+CORE processor
   Copyright (C) 2005, 2007 Free Software Foundation, Inc.
   Contributed by Sunnorth
 
   This file is part of GCC.
 
   GCC 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.
 
   GCC 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 GCC; see the file COPYING3.  If not see
   <http://www.gnu.org/licenses/>.  */
 
#ifndef SCORE_MDAUX_0621
#define SCORE_MDAUX_0621
 
/* Machine Auxiliary Functions.  */
enum score_address_type
{
  ADD_REG,
  ADD_CONST_INT,
  ADD_SYMBOLIC
};
#ifdef RTX_CODE
struct score_address_info
{
  enum score_address_type type;
  rtx reg;
  rtx offset;
  enum rtx_code code;
  enum score_symbol_type symbol_type;
};
#endif
 
struct score_frame_info
{
  HOST_WIDE_INT total_size;       /* bytes that the entire frame takes up  */
  HOST_WIDE_INT var_size;         /* bytes that variables take up  */
  HOST_WIDE_INT args_size;        /* bytes that outgoing arguments take up  */
  HOST_WIDE_INT gp_reg_size;      /* bytes needed to store gp regs  */
  HOST_WIDE_INT gp_sp_offset;     /* offset from new sp to store gp registers  */
  HOST_WIDE_INT cprestore_size;   /* # bytes that the .cprestore slot takes up  */
  unsigned int  mask;             /* mask of saved gp registers  */
  int num_gp;                     /* number of gp registers saved  */
};
 
typedef void (*score_save_restore_fn) (rtx, rtx);
 
int mda_valid_base_register_p (rtx x, int strict);
 
#ifdef RTX_CODE
int mda_classify_address (struct score_address_info *info,
                          enum machine_mode mode, rtx x, int strict);
 
struct score_frame_info *mda_compute_frame_size (HOST_WIDE_INT size);
 
struct score_frame_info *mda_cached_frame (void);
 
void mda_gen_cmp (enum machine_mode mode);
#endif
 
int mda_symbolic_constant_p (rtx x, enum score_symbol_type *symbol_type);
 
int mda_bp (void);
 
/* Machine Expand.  */
void mdx_prologue (void);
 
void mdx_epilogue (int sibcall_p);
 
void mdx_movsicc (rtx *ops);
 
void mdx_call (rtx *ops, bool sibcall);
 
void mdx_call_value (rtx *ops, bool sibcall);
 
/* Machine Split.  */
void mds_movdi (rtx *ops);
 
void mds_zero_extract_andi (rtx *ops);
 
/* Machine Print.  */
enum mda_mem_unit {MDA_BYTE = 0, MDA_HWORD = 1, MDA_WORD = 2};
 
#define MDA_ALIGN_UNIT(V, UNIT)   !(V & ((1 << UNIT) - 1))
 
const char * mdp_linsn (rtx *ops, enum mda_mem_unit unit, bool sign);
 
const char * mdp_sinsn (rtx *ops, enum mda_mem_unit unit);
 
const char * mdp_select_add_imm (rtx *ops, bool set_cc);
 
const char * mdp_select (rtx *ops, const char *inst_pre,
                        bool commu, const char *letter, bool set_cc);
 
const char * mdp_limm (rtx *ops);
 
const char * mdp_move (rtx *ops);
 
/* Machine unaligned memory load/store. */
bool mdx_unaligned_load (rtx* ops);
 
bool mdx_unaligned_store (rtx* ops);
 
bool mdx_block_move (rtx* ops);
 
#endif