gcc/config/sh/sh-protos.h

   1 /* Definitions of target machine for GNU compiler for Renesas / SuperH SH.
   2    Copyright (C) 1993-2015 Free Software Foundation, Inc.
   3    Contributed by Steve Chamberlain (sac@cygnus.com).
   4    Improved by Jim Wilson (wilson@cygnus.com).
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #ifndef GCC_SH_PROTOS_H
  23 #define GCC_SH_PROTOS_H
  24
  25 enum sh_function_kind {
  26   /* A function with normal C ABI  */
  27   FUNCTION_ORDINARY,
  28   /* A special function that guarantees that some otherwise call-clobbered
  29      registers are not clobbered.  These can't go through the SH5 resolver,
  30      because it only saves argument passing registers.  */
  31   SFUNC_GOT,
  32   /* A special function that should be linked statically.  These are typically
  33      smaller or not much larger than a PLT entry.
  34      Some also have a non-standard ABI which precludes dynamic linking.  */
  35   SFUNC_STATIC
  36 };
  37
  38 /* Atomic model.  */
  39 struct sh_atomic_model
  40 {
  41   enum enum_type
  42   {
  43     none = 0,
  44     soft_gusa,
  45     hard_llcs,
  46     soft_tcb,
  47     soft_imask,
  48
  49     num_models
  50   };
  51
  52   /*  If strict is set, disallow mixing of different models, as it would
  53       happen on SH4A.  */
  54   bool strict;
  55   enum_type type;
  56
  57   /* Name string as it was specified on the command line.  */
  58   const char* name;
  59
  60   /* Name string as it is used in C/C++ defines.  */
  61   const char* cdef_name;
  62
  63   /* GBR offset variable for TCB model.  */
  64   int tcb_gbr_offset;
  65 };
  66
  67 extern const sh_atomic_model& selected_atomic_model (void);
  68
  69 /* Shortcuts to check the currently selected atomic model.  */
  70 #define TARGET_ATOMIC_ANY \
  71   selected_atomic_model ().type != sh_atomic_model::none
  72
  73 #define TARGET_ATOMIC_STRICT \
  74   selected_atomic_model ().strict
  75
  76 #define TARGET_ATOMIC_SOFT_GUSA \
  77   selected_atomic_model ().type == sh_atomic_model::soft_gusa
  78
  79 #define TARGET_ATOMIC_HARD_LLCS \
  80   selected_atomic_model ().type == sh_atomic_model::hard_llcs
  81
  82 #define TARGET_ATOMIC_SOFT_TCB \
  83   selected_atomic_model ().type == sh_atomic_model::soft_tcb
  84
  85 #define TARGET_ATOMIC_SOFT_TCB_GBR_OFFSET_RTX \
  86   GEN_INT (selected_atomic_model ().tcb_gbr_offset)
  87
  88 #define TARGET_ATOMIC_SOFT_IMASK \
  89   selected_atomic_model ().type == sh_atomic_model::soft_imask
  90
  91 #ifdef RTX_CODE
  92 extern rtx sh_fsca_sf2int (void);
  93 extern rtx sh_fsca_int2sf (void);
  94
  95 /* Declare functions defined in sh.c and used in templates.  */
  96
  97 extern const char *output_branch (int, rtx_insn *, rtx *);
  98 extern const char *output_ieee_ccmpeq (rtx_insn *, rtx *);
  99 extern const char *output_branchy_insn (enum rtx_code, const char *,
 100                                         rtx_insn *, rtx *);
 101 extern const char *output_movedouble (rtx, rtx[], machine_mode);
 102 extern const char *output_movepcrel (rtx, rtx[], machine_mode);
 103 extern const char *output_far_jump (rtx_insn *, rtx);
 104
 105 extern rtx sfunc_uses_reg (rtx_insn *);
 106 extern int barrier_align (rtx_insn *);
 107 extern int sh_loop_align (rtx_insn *);
 108 extern bool fp_zero_operand (rtx);
 109 extern bool fp_one_operand (rtx);
 110 extern bool sh_legitimate_index_p (machine_mode, rtx, bool, bool);
 111 extern bool sh_legitimize_reload_address (rtx *, machine_mode, int, int);
 112 extern rtx legitimize_pic_address (rtx, machine_mode, rtx);
 113 extern bool nonpic_symbol_mentioned_p (rtx);
 114 extern void output_pic_addr_const (FILE *, rtx);
 115 extern bool expand_block_move (rtx *);
 116 extern void prepare_move_operands (rtx[], machine_mode mode);
 117 extern bool sh_expand_cmpstr (rtx *);
 118 extern bool sh_expand_cmpnstr (rtx *);
 119 extern bool sh_expand_strlen  (rtx *);
 120 extern void sh_expand_setmem (rtx *);
 121 extern enum rtx_code prepare_cbranch_operands (rtx *, machine_mode mode,
 122                                                enum rtx_code comparison);
 123 extern void expand_cbranchsi4 (rtx *operands, enum rtx_code comparison, int);
 124 extern bool expand_cbranchdi4 (rtx *operands, enum rtx_code comparison);
 125 extern void sh_emit_scc_to_t (enum rtx_code, rtx, rtx);
 126 extern rtx sh_emit_cheap_store_flag (machine_mode, enum rtx_code, rtx, rtx);
 127 extern void sh_emit_compare_and_branch (rtx *, machine_mode);
 128 extern void sh_emit_compare_and_set (rtx *, machine_mode);
 129 extern bool sh_ashlsi_clobbers_t_reg_p (rtx);
 130 extern bool sh_lshrsi_clobbers_t_reg_p (rtx);
 131 extern void gen_shifty_op (int, rtx *);
 132 extern void gen_shifty_hi_op (int, rtx *);
 133 extern bool expand_ashiftrt (rtx *);
 134 extern bool sh_dynamicalize_shift_p (rtx);
 135 extern int shl_and_kind (rtx, rtx, int *);
 136 extern int shl_and_length (rtx);
 137 extern int shl_and_scr_length (rtx);
 138 extern bool gen_shl_and (rtx, rtx, rtx, rtx);
 139 extern int shl_sext_kind (rtx, rtx, int *);
 140 extern int shl_sext_length (rtx);
 141 extern bool gen_shl_sext (rtx, rtx, rtx, rtx);
 142 extern rtx gen_datalabel_ref (rtx);
 143 extern int regs_used (rtx, int);
 144 extern void fixup_addr_diff_vecs (rtx_insn *);
 145 extern int get_dest_uid (rtx, int);
 146 extern void final_prescan_insn (rtx_insn *, rtx *, int);
 147 extern enum tls_model tls_symbolic_operand (rtx, machine_mode);
 148 extern bool system_reg_operand (rtx, machine_mode);
 149 extern bool reg_unused_after (rtx, rtx_insn *);
 150 extern int sh_insn_length_adjustment (rtx_insn *);
 151 extern bool sh_can_redirect_branch (rtx_insn *, rtx_insn *);
 152 extern void sh_expand_unop_v2sf (enum rtx_code, rtx, rtx);
 153 extern void sh_expand_binop_v2sf (enum rtx_code, rtx, rtx, rtx);
 154 extern bool sh_expand_t_scc (rtx *);
 155 extern rtx sh_gen_truncate (machine_mode, rtx, int);
 156 extern bool sh_vector_mode_supported_p (machine_mode);
 157 extern bool sh_cfun_trap_exit_p (void);
 158 extern rtx sh_find_equiv_gbr_addr (rtx_insn* cur_insn, rtx mem);
 159 extern int sh_eval_treg_value (rtx op);
 160 extern HOST_WIDE_INT sh_disp_addr_displacement (rtx mem_op);
 161 extern int sh_max_mov_insn_displacement (machine_mode mode, bool consider_sh2a);
 162 extern bool sh_movsf_ie_ra_split_p (rtx, rtx, rtx);
 163
 164 /* Result value of sh_find_set_of_reg.  */
 165 struct set_of_reg
 166 {
 167   /* The insn where sh_find_set_of_reg stopped looking.
 168      Can be NULL_RTX if the end of the insn list was reached.  */
 169   rtx_insn* insn;
 170
 171   /* The set rtx of the specified reg if found, NULL_RTX otherwise.  */
 172   const_rtx set_rtx;
 173
 174   /* The set source rtx of the specified reg if found, NULL_RTX otherwise.
 175      Usually, this is the most interesting return value.  */
 176   rtx set_src;
 177 };
 178
 179 /* Given a reg rtx and a start insn, try to find the insn that sets the
 180    specified reg by using the specified insn stepping function, such as
 181    'prev_nonnote_insn_bb'.  When the insn is found, try to extract the rtx
 182    of the reg set.  */
 183 template <typename F> inline set_of_reg
 184 sh_find_set_of_reg (rtx reg, rtx_insn* insn, F stepfunc,
 185                     bool ignore_reg_reg_copies = false)
 186 {
 187   set_of_reg result;
 188   result.insn = insn;
 189   result.set_rtx = NULL_RTX;
 190   result.set_src = NULL_RTX;
 191
 192   if (!REG_P (reg) || insn == NULL_RTX)
 193     return result;
 194
 195   for (result.insn = stepfunc (insn); result.insn != NULL_RTX;
 196        result.insn = stepfunc (result.insn))
 197     {
 198       if (BARRIER_P (result.insn))
 199         return result;
 200       if (!NONJUMP_INSN_P (result.insn))
 201         continue;
 202       if (reg_set_p (reg, result.insn))
 203         {
 204           result.set_rtx = set_of (reg, result.insn);
 205
 206           if (result.set_rtx == NULL_RTX || GET_CODE (result.set_rtx) != SET)
 207             return result;
 208
 209           result.set_src = XEXP (result.set_rtx, 1);
 210
 211           if (ignore_reg_reg_copies && REG_P (result.set_src))
 212             {
 213               reg = result.set_src;
 214               continue;
 215             }
 216           if (ignore_reg_reg_copies && SUBREG_P (result.set_src)
 217               && REG_P (SUBREG_REG (result.set_src)))
 218             {
 219               reg = SUBREG_REG (result.set_src);
 220               continue;
 221             }
 222
 223           return result;
 224         }
 225     }
 226
 227   return result;
 228 }
 229
 230 /* Result value of sh_find_extending_set_of_reg.  */
 231 struct sh_extending_set_of_reg : public set_of_reg
 232 {
 233   /* The mode the set is extending from (QImode or HImode), or VOIDmode if
 234      this is not a zero/sign extending set.  */
 235   machine_mode from_mode;
 236
 237   /* ZERO_EXTEND, SIGN_EXTEND or UNKNOWN.  */
 238   rtx_code ext_code;
 239
 240   sh_extending_set_of_reg (rtx_insn* i)
 241   {
 242     insn = i;
 243     set_rtx = NULL;
 244     set_src = NULL;
 245     from_mode = VOIDmode;
 246     ext_code = UNKNOWN;
 247   }
 248
 249   sh_extending_set_of_reg (const set_of_reg& rhs)
 250   {
 251     *((set_of_reg*)this) = rhs;
 252     from_mode = VOIDmode;
 253     ext_code = UNKNOWN;
 254   }
 255
 256   /* Returns the reg rtx of the sign or zero extending result, that can be
 257      safely used at the specified insn in SImode.  If the set source is an
 258      implicitly sign extending mem load, the mem load is converted into an
 259      explicitly sign extending mem load.  */
 260   rtx use_as_extended_reg (rtx_insn* use_at_insn) const;
 261 };
 262
 263 extern sh_extending_set_of_reg sh_find_extending_set_of_reg (rtx reg,
 264                                                              rtx_insn* insn);
 265
 266 extern bool sh_is_logical_t_store_expr (rtx op, rtx_insn* insn);
 267 extern rtx sh_try_omit_signzero_extend (rtx extended_op, rtx_insn* insn);
 268 extern bool sh_split_movrt_negc_to_movt_xor (rtx_insn* curr_insn,
 269                                              rtx operands[]);
 270 extern void sh_split_tst_subregs (rtx_insn* curr_insn,
 271                                   machine_mode subreg_mode, int subreg_offset,
 272                                   rtx operands[]);
 273 extern void sh_remove_reg_dead_or_unused_notes (rtx_insn* i, int regno);
 274 #endif /* RTX_CODE */
 275
 276 extern void sh_cpu_cpp_builtins (cpp_reader* pfile);
 277
 278 extern const char *output_jump_label_table (void);
 279 extern rtx get_t_reg_rtx (void);
 280 extern int sh_media_register_for_return (void);
 281 extern void sh_expand_prologue (void);
 282 extern void sh_expand_epilogue (bool);
 283 extern void sh_set_return_address (rtx, rtx);
 284 extern int initial_elimination_offset (int, int);
 285 extern bool sh_hard_regno_rename_ok (unsigned int, unsigned int);
 286 extern bool sh_cfun_interrupt_handler_p (void);
 287 extern bool sh_cfun_resbank_handler_p (void);
 288 extern bool sh_attr_renesas_p (const_tree);
 289 extern bool sh_cfun_attr_renesas_p (void);
 290 extern bool sh_cannot_change_mode_class
 291               (machine_mode, machine_mode, enum reg_class);
 292 extern bool sh_small_register_classes_for_mode_p (machine_mode);
 293 extern void sh_mark_label (rtx, int);
 294 extern bool check_use_sfunc_addr (rtx_insn *, rtx);
 295
 296 #ifdef HARD_CONST
 297 extern void fpscr_set_from_mem (int, HARD_REG_SET);
 298 #endif
 299
 300 extern void sh_pr_interrupt (struct cpp_reader *);
 301 extern void sh_pr_trapa (struct cpp_reader *);
 302 extern void sh_pr_nosave_low_regs (struct cpp_reader *);
 303 extern rtx function_symbol (rtx, const char *, enum sh_function_kind);
 304 extern rtx sh_get_pr_initial_val (void);
 305
 306 extern void sh_init_cumulative_args (CUMULATIVE_ARGS *, tree, rtx, tree,
 307                                      signed int, machine_mode);
 308 extern rtx sh_dwarf_register_span (rtx);
 309
 310 extern rtx replace_n_hard_rtx (rtx, rtx *, int , int);
 311 extern int shmedia_cleanup_truncate (rtx);
 312
 313 extern bool sh_contains_memref_p (rtx);
 314 extern bool sh_loads_bankedreg_p (rtx);
 315 extern rtx shmedia_prepare_call_address (rtx fnaddr, int is_sibcall);
 316 extern int sh2a_get_function_vector_number (rtx);
 317 extern bool sh2a_is_function_vector_call (rtx);
 318 extern void sh_fix_range (const char *);
 319 extern bool sh_hard_regno_mode_ok (unsigned int, machine_mode);
 320 extern machine_mode sh_hard_regno_caller_save_mode (unsigned int, unsigned int,
 321                                                     machine_mode);
 322 extern bool sh_can_use_simple_return_p (void);
 323 #endif /* ! GCC_SH_PROTOS_H */