CbC/CbC_gcc: gcc/targhooks.c comparison

comparison gcc/targhooks.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Default target hook functions.
-Copyright (C) 2003-2018 Free Software Foundation, Inc.
+Copyright (C) 2003-2020 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 "reload.h"
 #include "intl.h"
 #include "opts.h"
 #include "gimplify.h"
 #include "predict.h"
-#include "params.h"
 #include "real.h"
 #include "langhooks.h"
 #include "sbitmap.h"
+#include "function-abi.h"
 bool
 default_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
 			      rtx addr ATTRIBUTE_UNUSED,
 			      bool strict ATTRIBUTE_UNUSED)
 }
 rtx
 default_expand_builtin_saveregs (void)
 {
-error ("__builtin_saveregs not supported by this target");
+error ("%<__builtin_saveregs%> not supported by this target");
 return const0_rtx;
 }
 void
-default_setup_incoming_varargs (cumulative_args_t ca ATTRIBUTE_UNUSED,
+default_setup_incoming_varargs (cumulative_args_t,
-				machine_mode mode ATTRIBUTE_UNUSED,
+				const function_arg_info &, int *, int)
-				tree type ATTRIBUTE_UNUSED,
-				int *pretend_arg_size ATTRIBUTE_UNUSED,
-				int second_time ATTRIBUTE_UNUSED)
 {
 }
 /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE.  */
 /* Return true if a parameter must be passed by reference.  This version
 of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK.  */
 bool
-hook_pass_by_reference_must_pass_in_stack (cumulative_args_t c ATTRIBUTE_UNUSED,
+hook_pass_by_reference_must_pass_in_stack (cumulative_args_t,
-	machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED,
+					   const function_arg_info &arg)
-	bool named_arg ATTRIBUTE_UNUSED)
+{
-{
+return targetm.calls.must_pass_in_stack (arg);
-return targetm.calls.must_pass_in_stack (mode, type);
 }
 /* Return true if a parameter follows callee copies conventions.  This
 version of the hook is true for all named arguments.  */
 bool
-hook_callee_copies_named (cumulative_args_t ca ATTRIBUTE_UNUSED,
+hook_callee_copies_named (cumulative_args_t, const function_arg_info &arg)
-			  machine_mode mode ATTRIBUTE_UNUSED,
+{
-			  const_tree type ATTRIBUTE_UNUSED, bool named)
+return arg.named;
-{
-return named;
 }
 /* Emit to STREAM the assembler syntax for insn operand X.  */
 void
 default_has_ifunc_p (void)
 {
 return HAVE_GNU_INDIRECT_FUNCTION;
 }
+/* Return true if we predict the loop LOOP will be transformed to a
+low-overhead loop, otherwise return false.
+By default, false is returned, as this hook's applicability should be
+verified for each target.  Target maintainers should re-define the hook
+if the target can take advantage of it.  */
+bool
+default_predict_doloop_p (class loop *loop ATTRIBUTE_UNUSED)
+{
+return false;
+}
 /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
 an error message.
 This function checks whether a given INSN is valid within a low-overhead
 loop.  If INSN is invalid it returns the reason for that, otherwise it
 /* Mapping of target builtin functions to vectorized variants.  */
 tree
 default_builtin_md_vectorized_function (tree, tree, tree)
-{
-return NULL_TREE;
-}
-/* Vectorized conversion.  */
-tree
-default_builtin_vectorized_conversion (unsigned int code ATTRIBUTE_UNUSED,
-				       tree dest_type ATTRIBUTE_UNUSED,
-				       tree src_type ATTRIBUTE_UNUSED)
 {
 return NULL_TREE;
 }
 /* Default vectorizer cost model values.  */
 {
 return NULL_TREE;
 }
 bool
-hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
+hook_bool_CUMULATIVE_ARGS_arg_info_false (cumulative_args_t,
-	cumulative_args_t ca ATTRIBUTE_UNUSED,
+					  const function_arg_info &)
-	machine_mode mode ATTRIBUTE_UNUSED,
-	const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 {
 return false;
 }
 bool
-hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
+hook_bool_CUMULATIVE_ARGS_arg_info_true (cumulative_args_t,
-	cumulative_args_t ca ATTRIBUTE_UNUSED,
+					 const function_arg_info &)
-	machine_mode mode ATTRIBUTE_UNUSED,
-	const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 {
 return true;
 }
 int
-hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
+hook_int_CUMULATIVE_ARGS_arg_info_0 (cumulative_args_t,
-	cumulative_args_t ca ATTRIBUTE_UNUSED,
+				     const function_arg_info &)
-	machine_mode mode ATTRIBUTE_UNUSED,
-	tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 {
 return 0;
 }
 void
 				tree ATTRIBUTE_UNUSED)
 {
 }
 void
-default_function_arg_advance (cumulative_args_t ca ATTRIBUTE_UNUSED,
+default_function_arg_advance (cumulative_args_t, const function_arg_info &)
-			      machine_mode mode ATTRIBUTE_UNUSED,
-			      const_tree type ATTRIBUTE_UNUSED,
-			      bool named ATTRIBUTE_UNUSED)
 {
 gcc_unreachable ();
 }
 /* Default implementation of TARGET_FUNCTION_ARG_OFFSET.  */
 return PAD_UPWARD;
 }
 rtx
-default_function_arg (cumulative_args_t ca ATTRIBUTE_UNUSED,
+default_function_arg (cumulative_args_t, const function_arg_info &)
-		      machine_mode mode ATTRIBUTE_UNUSED,
-		      const_tree type ATTRIBUTE_UNUSED,
-		      bool named ATTRIBUTE_UNUSED)
 {
 gcc_unreachable ();
 }
 rtx
-default_function_incoming_arg (cumulative_args_t ca ATTRIBUTE_UNUSED,
+default_function_incoming_arg (cumulative_args_t, const function_arg_info &)
-			       machine_mode mode ATTRIBUTE_UNUSED,
-			       const_tree type ATTRIBUTE_UNUSED,
-			       bool named ATTRIBUTE_UNUSED)
 {
 gcc_unreachable ();
 }
 unsigned int
 poly_int64
 default_return_pops_args (tree, tree, poly_int64)
 {
 return 0;
-}
-reg_class_t
-default_branch_target_register_class (void)
-{
-return NO_REGS;
 }
 reg_class_t
 default_ira_change_pseudo_allocno_class (int regno ATTRIBUTE_UNUSED,
 					 reg_class_t cl,
 if (TREE_CODE (exp) == STRING_CST)
 return MAX (align, BITS_PER_WORD);
 return align;
 }
-/* Default to natural alignment for vector types.  */
+/* Default to natural alignment for vector types, bounded by
+MAX_OFILE_ALIGNMENT.  */
 HOST_WIDE_INT
 default_vector_alignment (const_tree type)
 {
-HOST_WIDE_INT align = tree_to_shwi (TYPE_SIZE (type));
+unsigned HOST_WIDE_INT align = MAX_OFILE_ALIGNMENT;
-if (align > MAX_OFILE_ALIGNMENT)
+tree size = TYPE_SIZE (type);
-align = MAX_OFILE_ALIGNMENT;
+if (tree_fits_uhwi_p (size))
-return align;
+align = tree_to_uhwi (size);
+return align < MAX_OFILE_ALIGNMENT ? align : MAX_OFILE_ALIGNMENT;
 }
 /* The default implementation of
 TARGET_VECTORIZE_PREFERRED_VECTOR_ALIGNMENT.  */
-HOST_WIDE_INT
+poly_uint64
 default_preferred_vector_alignment (const_tree type)
 {
 return TYPE_ALIGN (type);
 }
 default_split_reduction (machine_mode mode)
 {
 return mode;
 }
-/* By default only the size derived from the preferred vector mode
+/* By default only the preferred vector mode is tried.  */
-is tried.  */
+unsigned int
-void
+default_autovectorize_vector_modes (vector_modes *, bool)
-default_autovectorize_vector_sizes (vector_sizes *)
+{
-{
+return 0;
+}
+/* The default implementation of TARGET_VECTORIZE_RELATED_MODE.  */
+opt_machine_mode
+default_vectorize_related_mode (machine_mode vector_mode,
+				scalar_mode element_mode,
+				poly_uint64 nunits)
+{
+machine_mode result_mode;
+if ((maybe_ne (nunits, 0U)
+|| multiple_p (GET_MODE_SIZE (vector_mode),
+		      GET_MODE_SIZE (element_mode), &nunits))
+&& mode_for_vector (element_mode, nunits).exists (&result_mode)
+&& VECTOR_MODE_P (result_mode)
+&& targetm.vector_mode_supported_p (result_mode))
+return result_mode;
+return opt_machine_mode ();
 }
 /* By default a vector of integers is used as a mask.  */
 opt_machine_mode
-default_get_mask_mode (poly_uint64 nunits, poly_uint64 vector_size)
+default_get_mask_mode (machine_mode mode)
 {
-unsigned int elem_size = vector_element_size (vector_size, nunits);
+return related_int_vector_mode (mode);
-scalar_int_mode elem_mode
-= smallest_int_mode_for_size (elem_size * BITS_PER_UNIT);
-machine_mode vector_mode;
-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
 /* 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.  */
 void *
-default_init_cost (struct loop *loop_info ATTRIBUTE_UNUSED)
+default_init_cost (class loop *loop_info ATTRIBUTE_UNUSED)
 {
 unsigned *cost = XNEWVEC (unsigned, 3);
 cost[vect_prologue] = cost[vect_body] = cost[vect_epilogue] = 0;
 return cost;
 }
 kind and mode, multiplies it by the occurrence count, accumulates
 it into the cost specified by WHERE, and returns the cost added.  */
 unsigned
 default_add_stmt_cost (void *data, int count, enum vect_cost_for_stmt kind,
-		       struct _stmt_vec_info *stmt_info, int misalign,
+		       class _stmt_vec_info *stmt_info, int misalign,
 		       enum vect_cost_model_location where)
 {
 unsigned *cost = (unsigned *) data;
 unsigned retval = 0;
 pointer to int.  We assume that accesses to errno are
 not deliberately obfuscated (even in conforming ways).  */
 if (TYPE_UNSIGNED (TREE_TYPE (base))
 || TYPE_MODE (TREE_TYPE (base)) != TYPE_MODE (integer_type_node))
 return false;
-/* The default implementation assumes an errno location
+/* The default implementation assumes an errno location declaration
-declaration is never defined in the current compilation unit.  */
+is never defined in the current compilation unit and may not be
+aliased by a local variable.  */
 if (DECL_P (base)
+&& DECL_EXTERNAL (base)
 && !TREE_STATIC (base))
 return true;
 else if (TREE_CODE (base) == MEM_REF
 	   && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
 {
 /* If args is NULL the caller is handle_pragma_pop_options ().  In that case,
 emit no warning because "#pragma GCC pop_target" is valid on targets that
 do not have the "target" pragma.  */
 if (args)
 warning (OPT_Wpragmas,
-	     "#pragma GCC target is not supported for this machine");
+	     "%<#pragma GCC target%> is not supported for this machine");
 return false;
 }
 bool
 return true;
 return false;
 }
+/* By default assume that libc has not a fast implementation.  */
+bool
+default_libc_has_fast_function (int fcode ATTRIBUTE_UNUSED)
+{
+return false;
+}
 bool
 gnu_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED)
 {
 return true;
 }
 {
 unsigned int move_ratio;
 #ifdef MOVE_RATIO
 move_ratio = (unsigned int) MOVE_RATIO (speed_p);
 #else
-#if defined (HAVE_movmemqi) || defined (HAVE_movmemhi) || defined (HAVE_movmemsi) || defined (HAVE_movmemdi) || defined (HAVE_movmemti)
+#if defined (HAVE_cpymemqi) || defined (HAVE_cpymemhi) || defined (HAVE_cpymemsi) || defined (HAVE_cpymemdi) || defined (HAVE_cpymemti)
 move_ratio = 2;
-#else /* No movmem patterns, pick a default.  */
+#else /* No cpymem patterns, pick a default.  */
 move_ratio = ((speed_p) ? 15 : 3);
 #endif
 #endif
 return move_ratio;
 }
 /* Return TRUE if the move_by_pieces/set_by_pieces infrastructure should be
-used; return FALSE if the movmem/setmem optab should be expanded, or
+used; return FALSE if the cpymem/setmem optab should be expanded, or
 a call to memcpy emitted.  */
 bool
 default_use_by_pieces_infrastructure_p (unsigned HOST_WIDE_INT size,
 					unsigned int alignment,
 if (record_p && targetm_common.have_named_sections)
 {
 char buf[256];
 static int patch_area_number;
 section *previous_section = in_section;
+const char *asm_op = integer_asm_op (POINTER_SIZE_UNITS, false);
+gcc_assert (asm_op != NULL);
 patch_area_number++;
 ASM_GENERATE_INTERNAL_LABEL (buf, "LPFE", patch_area_number);
 switch_to_section (get_section ("__patchable_function_entries",
-				      0, NULL));
+				      SECTION_WRITE | SECTION_RELRO, NULL));
-fputs (integer_asm_op (POINTER_SIZE_UNITS, false), file);
+assemble_align (POINTER_SIZE);
+fputs (asm_op, file);
 assemble_name_raw (file, buf);
 fputc ('\n', file);
 switch_to_section (previous_section);
 ASM_OUTPUT_LABEL (file, buf);
 }
 unsigned i;
 for (i = 0; i < patch_area_size; ++i)
-fprintf (file, "\t%s\n", nop_templ);
+output_asm_insn (nop_templ, NULL);
 }
 bool
 default_profile_before_prologue (void)
 {
 machine_mode
 default_dwarf_frame_reg_mode (int regno)
 {
 machine_mode save_mode = reg_raw_mode[regno];
-if (targetm.hard_regno_call_part_clobbered (regno, save_mode))
+if (targetm.hard_regno_call_part_clobbered (eh_edge_abi.id (),
-save_mode = choose_hard_reg_mode (regno, 1, true);
+					      regno, save_mode))
+save_mode = choose_hard_reg_mode (regno, 1, &eh_edge_abi);
 return save_mode;
 }
 /* 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.  */
 const char *data = (const char *)data_p;
 size_t i;
 /* -fpic and -fpie also usually make a PCH invalid.  */
 if (data[0] != flag_pic)
-return _("created and used with different settings of -fpic");
+return _("created and used with different settings of %<-fpic%>");
 if (data[1] != flag_pie)
-return _("created and used with different settings of -fpie");
+return _("created and used with different settings of %<-fpie%>");
 data += 2;
 /* Check target_flags.  */
 if (targetm.check_pch_target_flags)
 {
 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
 implement their own specialized gimplify_va_arg_expr routines.  */
 if (ARGS_GROW_DOWNWARD)
 gcc_unreachable ();
-indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
+indirect = pass_va_arg_by_reference (type);
 if (indirect)
 type = build_pointer_type (type);
 if (targetm.calls.split_complex_arg
 && TREE_CODE (type) == COMPLEX_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);
+real_part = get_initialized_tmp_var (real_part, pre_p);
 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);
+imag_part = get_initialized_tmp_var (imag_part, pre_p);
 return build2 (COMPLEX_EXPR, type, real_part, imag_part);
 }
 align = PARM_BOUNDARY / BITS_PER_UNIT;
 boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
 boundary /= BITS_PER_UNIT;
 /* Hoist the valist value into a temporary for the moment.  */
-valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
+valist_tmp = get_initialized_tmp_var (valist, pre_p);
 /* 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)
 addr = build_va_arg_indirect_ref (addr);
 return build_va_arg_indirect_ref (addr);
 }
-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,
-				      int second_time ATTRIBUTE_UNUSED)
-{
-}
 /* An implementation of TARGET_CAN_USE_DOLOOP_P for targets that do
 not support nested low-overhead loops.  */
 bool
 can_use_doloop_if_innermost (const widest_int &, const widest_int &,
 unsigned int
 default_max_noce_ifcvt_seq_cost (edge e)
 {
 bool predictable_p = predictable_edge_p (e);
-enum compiler_param param
+if (predictable_p)
-= (predictable_p
+{
-? PARAM_MAX_RTL_IF_CONVERSION_PREDICTABLE_COST
+if (global_options_set.x_param_max_rtl_if_conversion_predictable_cost)
-: PARAM_MAX_RTL_IF_CONVERSION_UNPREDICTABLE_COST);
+	return param_max_rtl_if_conversion_predictable_cost;
+}
-/* If we have a parameter set, use that, otherwise take a guess using
-BRANCH_COST.  */
-if (global_options_set.x_param_values[param])
-return PARAM_VALUE (param);
 else
-return BRANCH_COST (true, predictable_p) * COSTS_N_INSNS (3);
+{
+if (global_options_set.x_param_max_rtl_if_conversion_unpredictable_cost)
+	return param_max_rtl_if_conversion_unpredictable_cost;
+}
+return BRANCH_COST (true, predictable_p) * COSTS_N_INSNS (3);
 }
 /* Default implementation of TARGET_MIN_ARITHMETIC_PRECISION.  */
 unsigned int

Mercurial > hg > CbC > CbC_gcc

comparison gcc/targhooks.c @ 145:1830386684a0