CbC/CbC_gcc: gcc/targhooks.c comparison

comparison gcc/targhooks.c @ 132:d34655255c78

update gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 10:21:07 +0900
parents	84e7813d76e9
children	1830386684a0

comparison

equal deleted inserted replaced

-:e108057fa461
+:d34655255c78
 /* Default target hook functions.
-Copyright (C) 2003-2017 Free Software Foundation, Inc.
+Copyright (C) 2003-2018 Free Software Foundation, Inc.
 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
 #include "opts.h"
 #include "gimplify.h"
 #include "predict.h"
 #include "params.h"
 #include "real.h"
+#include "langhooks.h"
+#include "sbitmap.h"
 bool
 default_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
 			      rtx addr ATTRIBUTE_UNUSED,
 			      bool strict ATTRIBUTE_UNUSED)
 {
 return x;
 }
 bool
-default_legitimize_address_displacement (rtx *disp ATTRIBUTE_UNUSED,
+default_legitimize_address_displacement (rtx *, rtx *, poly_int64,
-					 rtx *offset ATTRIBUTE_UNUSED,
+					 machine_mode)
-					 machine_mode mode ATTRIBUTE_UNUSED)
 {
 return false;
 }
 bool
 const char *skipped = name + (*name == '*' ? 1 : 0);
 const char *stripped = targetm.strip_name_encoding (skipped);
 if (*name != '*' && user_label_prefix[0])
 stripped = ACONCAT ((user_label_prefix, stripped, NULL));
 return get_identifier (stripped);
+}
+/* The default implementation of TARGET_TRANSLATE_MODE_ATTRIBUTE.  */
+machine_mode
+default_translate_mode_attribute (machine_mode mode)
+{
+return mode;
 }
 /* True if MODE is valid for the target.  By "valid", we mean able to
 be manipulated in non-trivial ways.  In particular, this means all
 the arithmetic is supported.
 	return cand;
 }
 return opt_scalar_float_mode ();
 }
+/* Define this to return true if the _Floatn and _Floatnx built-in functions
+should implicitly enable the built-in function without the __builtin_ prefix
+in addition to the normal built-in function with the __builtin_ prefix.  The
+default is to only enable built-in functions without the __builtin_ prefix
+for the GNU C langauge.  The argument FUNC is the enum builtin_in_function
+id of the function to be enabled.  */
+bool
+default_floatn_builtin_p (int func ATTRIBUTE_UNUSED)
+{
+static bool first_time_p = true;
+static bool c_or_objective_c;
+if (first_time_p)
+{
+first_time_p = false;
+c_or_objective_c = lang_GNU_C () || lang_GNU_OBJC ();
+}
+return c_or_objective_c;
+}
 /* Make some target macros useable by target-independent code.  */
 bool
 targhook_words_big_endian (void)
 {
 return !!WORDS_BIG_ENDIAN;
 case cond_branch_taken:
 return 3;
 case vec_construct:
-	return TYPE_VECTOR_SUBPARTS (vectype) - 1;
+	return estimated_poly_value (TYPE_VECTOR_SUBPARTS (vectype)) - 1;
 default:
 gcc_unreachable ();
 }
 }
 	cumulative_args_t ca ATTRIBUTE_UNUSED,
 	machine_mode mode ATTRIBUTE_UNUSED,
 	tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 {
 return 0;
+}
+void
+hook_void_CUMULATIVE_ARGS_tree (cumulative_args_t ca ATTRIBUTE_UNUSED,
+				tree ATTRIBUTE_UNUSED)
+{
 }
 void
 default_function_arg_advance (cumulative_args_t ca ATTRIBUTE_UNUSED,
 			      machine_mode mode ATTRIBUTE_UNUSED,
 if (!type || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
 	return PAD_UPWARD;
 size = int_size_in_bytes (type);
 }
 else
-size = GET_MODE_SIZE (mode);
+/* Targets with variable-sized modes must override this hook
+and handle variable-sized modes explicitly.  */
+size = GET_MODE_SIZE (mode).to_constant ();
 if (size < (PARM_BOUNDARY / BITS_PER_UNIT))
 return PAD_DOWNWARD;
 return PAD_UPWARD;
 rtx
 default_libcall_value (machine_mode mode ATTRIBUTE_UNUSED,
 		       const_rtx fun ATTRIBUTE_UNUSED)
 {
 #ifdef LIBCALL_VALUE
-return LIBCALL_VALUE (mode);
+return LIBCALL_VALUE (MACRO_MODE (mode));
 #else
 gcc_unreachable ();
 #endif
 }
 			 rtx ARG_UNUSED (r_chain))
 {
 sorry ("nested function trampolines not supported on this target");
 }
-int
+poly_int64
-default_return_pops_args (tree fundecl ATTRIBUTE_UNUSED,
+default_return_pops_args (tree, tree, poly_int64)
-			  tree funtype ATTRIBUTE_UNUSED,
-			  int size ATTRIBUTE_UNUSED)
 {
 return 0;
 }
 reg_class_t
 sri->icode = sri->prev_sri->t_icode;
 return NO_REGS;
 }
 #ifdef SECONDARY_INPUT_RELOAD_CLASS
 if (in_p)
-rclass = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
+rclass = SECONDARY_INPUT_RELOAD_CLASS (reload_class,
+					   MACRO_MODE (reload_mode), x);
 #endif
 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
 if (! in_p)
-rclass = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
+rclass = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class,
+					    MACRO_MODE (reload_mode), x);
 #endif
 if (rclass != NO_REGS)
 {
 enum insn_code icode
 	= direct_optab_handler (in_p ? reload_in_optab : reload_out_optab,
 machine_mode
 default_secondary_memory_needed_mode (machine_mode mode)
 {
 if (!targetm.lra_p ()
-&& GET_MODE_BITSIZE (mode) < BITS_PER_WORD
+&& known_lt (GET_MODE_BITSIZE (mode), BITS_PER_WORD)
 && INTEGRAL_MODE_P (mode))
 return mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (mode), 0).require ();
 return mode;
 }
 int
 default_reloc_rw_mask (void)
 {
 return flag_pic ? 3 : 0;
+}
+/* By default, address diff vectors are generated
+for jump tables when flag_pic is true.  */
+bool
+default_generate_pic_addr_diff_vec (void)
+{
+return flag_pic;
 }
 /* By default, do no modification. */
 tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
 					 tree id)
 default_preferred_simd_mode (scalar_mode)
 {
 return word_mode;
 }
+/* By default do not split reductions further.  */
+machine_mode
+default_split_reduction (machine_mode mode)
+{
+return mode;
+}
 /* By default only the size derived from the preferred vector mode
 is tried.  */
-unsigned int
+void
-default_autovectorize_vector_sizes (void)
+default_autovectorize_vector_sizes (vector_sizes *)
 {
-return 0;
+}
-}
+/* By default a vector of integers is used as a mask.  */
-/* By defaults a vector of integers is used as a mask.  */
 opt_machine_mode
-default_get_mask_mode (unsigned nunits, unsigned vector_size)
+default_get_mask_mode (poly_uint64 nunits, poly_uint64 vector_size)
 {
-unsigned elem_size = vector_size / nunits;
+unsigned int elem_size = vector_element_size (vector_size, nunits);
 scalar_int_mode elem_mode
 = smallest_int_mode_for_size (elem_size * BITS_PER_UNIT);
 machine_mode vector_mode;
-gcc_assert (elem_size * nunits == vector_size);
+gcc_assert (known_eq (elem_size * nunits, vector_size));
 if (mode_for_vector (elem_mode, nunits).exists (&vector_mode)
 && VECTOR_MODE_P (vector_mode)
 && targetm.vector_mode_supported_p (vector_mode))
 return vector_mode;
 return opt_machine_mode ();
+}
+/* By default consider masked stores to be expensive.  */
+bool
+default_empty_mask_is_expensive (unsigned ifn)
+{
+return ifn == IFN_MASK_STORE;
 }
 /* By default, the cost model accumulates three separate costs (prologue,
 loop body, and epilogue) for a vectorized loop or block.  So allocate an
 array of three unsigned ints, set it to zero, and return its address.  */
 /* The defualt implementation of TARGET_HARD_REGNO_NREGS.  */
 unsigned int
 default_hard_regno_nregs (unsigned int, machine_mode mode)
 {
-return CEIL (GET_MODE_SIZE (mode), UNITS_PER_WORD);
+/* Targets with variable-sized modes must provide their own definition
+of this hook.  */
+return CEIL (GET_MODE_SIZE (mode).to_constant (), UNITS_PER_WORD);
 }
 bool
 default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
 {
 			  bool in ATTRIBUTE_UNUSED)
 {
 #ifndef MEMORY_MOVE_COST
 return (4 + memory_move_secondary_cost (mode, (enum reg_class) rclass, in));
 #else
-return MEMORY_MOVE_COST (mode, (enum reg_class) rclass, in);
+return MEMORY_MOVE_COST (MACRO_MODE (mode), (enum reg_class) rclass, in);
 #endif
 }
 /* Compute cost of moving data from a register of class FROM to one of
 TO, using MODE.  */
 reg_class_t to ATTRIBUTE_UNUSED)
 {
 #ifndef REGISTER_MOVE_COST
 return 2;
 #else
-return REGISTER_MOVE_COST (mode, (enum reg_class) from, (enum reg_class) to);
+return REGISTER_MOVE_COST (MACRO_MODE (mode),
+			     (enum reg_class) from, (enum reg_class) to);
 #endif
 }
 /* The default implementation of TARGET_SLOW_UNALIGNED_ACCESS.  */
 bool
 default_slow_unaligned_access (machine_mode, unsigned int)
 {
 return STRICT_ALIGNMENT;
+}
+/* The default implementation of TARGET_ESTIMATED_POLY_VALUE.  */
+HOST_WIDE_INT
+default_estimated_poly_value (poly_int64 x)
+{
+return x.coeffs[0];
 }
 /* For hooks which use the MOVE_RATIO macro, this gives the legacy default
 behavior.  SPEED_P is true if we are compiling for speed.  */
 unsigned char
 default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED,
 			 machine_mode mode ATTRIBUTE_UNUSED)
 {
 #ifdef CLASS_MAX_NREGS
-return (unsigned char) CLASS_MAX_NREGS ((enum reg_class) rclass, mode);
+return (unsigned char) CLASS_MAX_NREGS ((enum reg_class) rclass,
+					  MACRO_MODE (mode));
 #else
-return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
+/* Targets with variable-sized modes must provide their own definition
+of this hook.  */
+unsigned int size = GET_MODE_SIZE (mode).to_constant ();
+return (size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
 #endif
 }
 /* Determine the debugging unwind mechanism for the target.  */
 #endif
 return UI_NONE;
 }
+/* Targets that set NUM_POLY_INT_COEFFS to something greater than 1
+must define this hook.  */
+unsigned int
+default_dwarf_poly_indeterminate_value (unsigned int, unsigned int *, int *)
+{
+gcc_unreachable ();
+}
 /* Determine the correct mode for a Dwarf frame register that represents
 register REGNO.  */
 machine_mode
 default_dwarf_frame_reg_mode (int regno)
 }
 /* To be used by targets where reg_raw_mode doesn't return the right
 mode for registers used in apply_builtin_return and apply_builtin_arg.  */
-machine_mode
+fixed_size_mode
 default_get_reg_raw_mode (int regno)
 {
-return reg_raw_mode[regno];
+/* Targets must override this hook if the underlying register is
+variable-sized.  */
+return as_a <fixed_size_mode> (reg_raw_mode[regno]);
 }
 /* Return true if a leaf function should stay leaf even with profiling
 enabled.  */
 indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
 if (indirect)
 type = build_pointer_type (type);
+if (targetm.calls.split_complex_arg
+&& TREE_CODE (type) == COMPLEX_TYPE
+&& targetm.calls.split_complex_arg (type))
+{
+tree real_part, imag_part;
+real_part = std_gimplify_va_arg_expr (valist,
+					    TREE_TYPE (type), pre_p, NULL);
+real_part = get_initialized_tmp_var (real_part, pre_p, NULL);
+imag_part = std_gimplify_va_arg_expr (unshare_expr (valist),
+					    TREE_TYPE (type), pre_p, NULL);
+imag_part = get_initialized_tmp_var (imag_part, pre_p, NULL);
+return build2 (COMPLEX_EXPR, type, real_part, imag_part);
+}
 align = PARM_BOUNDARY / BITS_PER_UNIT;
 boundary = targetm.calls.function_arg_boundary (TYPE_MODE (type), type);
 /* When we align parameter on stack for caller, if the parameter
 alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
 valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
 /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
 requires greater alignment, we must perform dynamic alignment.  */
 if (boundary > align
+&& !TYPE_EMPTY_P (type)
 && !integer_zerop (TYPE_SIZE (type)))
 {
 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
 		  fold_build_pointer_plus_hwi (valist_tmp, boundary - 1));
 gimplify_and_add (t, pre_p);
 type = build_variant_type_copy (type);
 SET_TYPE_ALIGN (type, boundary);
 }
 /* Compute the rounded size of the type.  */
-type_size = size_in_bytes (type);
+type_size = arg_size_in_bytes (type);
 rounded_size = round_up (type_size, align);
 /* Reduce rounded_size so it's sharable with the postqueue.  */
 gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
 addr = build_va_arg_indirect_ref (addr);
 return build_va_arg_indirect_ref (addr);
 }
-tree
-default_chkp_bound_type (void)
-{
-tree res = make_node (POINTER_BOUNDS_TYPE);
-TYPE_PRECISION (res) = TYPE_PRECISION (size_type_node) * 2;
-TYPE_NAME (res) = get_identifier ("__bounds_type");
-SET_TYPE_MODE (res, targetm.chkp_bound_mode ());
-layout_type (res);
-return res;
-}
-machine_mode
-default_chkp_bound_mode (void)
-{
-return VOIDmode;
-}
-tree
-default_builtin_chkp_function (unsigned int fcode ATTRIBUTE_UNUSED)
-{
-return NULL_TREE;
-}
-rtx
-default_chkp_function_value_bounds (const_tree ret_type ATTRIBUTE_UNUSED,
-				    const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
-				    bool outgoing ATTRIBUTE_UNUSED)
-{
-gcc_unreachable ();
-}
-tree
-default_chkp_make_bounds_constant (HOST_WIDE_INT lb ATTRIBUTE_UNUSED,
-				   HOST_WIDE_INT ub ATTRIBUTE_UNUSED)
-{
-return NULL_TREE;
-}
-int
-default_chkp_initialize_bounds (tree var ATTRIBUTE_UNUSED,
-				tree lb ATTRIBUTE_UNUSED,
-				tree ub ATTRIBUTE_UNUSED,
-				tree *stmts ATTRIBUTE_UNUSED)
-{
-return 0;
-}
 void
 default_setup_incoming_vararg_bounds (cumulative_args_t ca ATTRIBUTE_UNUSED,
 				      machine_mode mode ATTRIBUTE_UNUSED,
 				      tree type ATTRIBUTE_UNUSED,
 				      int *pretend_arg_size ATTRIBUTE_UNUSED,
 default_excess_precision (enum excess_precision_type ATTRIBUTE_UNUSED)
 {
 return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT;
 }
-bool
+/* Default implementation for
-default_stack_clash_protection_final_dynamic_probe (rtx residual ATTRIBUTE_UNUSED)
+TARGET_STACK_CLASH_PROTECTION_ALLOCA_PROBE_RANGE.  */
+HOST_WIDE_INT
+default_stack_clash_protection_alloca_probe_range (void)
 {
 return 0;
 }
+/* The default implementation of TARGET_EARLY_REMAT_MODES.  */
+void
+default_select_early_remat_modes (sbitmap)
+{
+}
+/* The default implementation of TARGET_PREFERRED_ELSE_VALUE.  */
+tree
+default_preferred_else_value (unsigned, tree type, unsigned, tree *)
+{
+return build_zero_cst (type);
+}
+/* Default implementation of TARGET_HAVE_SPECULATION_SAFE_VALUE.  */
+bool
+default_have_speculation_safe_value (bool active ATTRIBUTE_UNUSED)
+{
+#ifdef HAVE_speculation_barrier
+return active ? HAVE_speculation_barrier : true;
+#else
+return false;
+#endif
+}
+/* Alternative implementation of TARGET_HAVE_SPECULATION_SAFE_VALUE
+that can be used on targets that never have speculative execution.  */
+bool
+speculation_safe_value_not_needed (bool active)
+{
+return !active;
+}
+/* Default implementation of the speculation-safe-load builtin.  This
+implementation simply copies val to result and generates a
+speculation_barrier insn, if such a pattern is defined.  */
+rtx
+default_speculation_safe_value (machine_mode mode ATTRIBUTE_UNUSED,
+				rtx result, rtx val,
+				rtx failval ATTRIBUTE_UNUSED)
+{
+emit_move_insn (result, val);
+#ifdef HAVE_speculation_barrier
+/* Assume the target knows what it is doing: if it defines a
+speculation barrier, but it is not enabled, then assume that one
+isn't needed.  */
+if (HAVE_speculation_barrier)
+emit_insn (gen_speculation_barrier ());
+#endif
+return result;
+}
 #include "gt-targhooks.h"

Mercurial > hg > CbC > CbC_gcc

comparison gcc/targhooks.c @ 132:d34655255c78