CbC/CbC_gcc: gcc/target.def comparison

comparison gcc/target.def @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Target hook definitions.
-Copyright (C) 2001-2017 Free Software Foundation, Inc.
+Copyright (C) 2001-2018 Free Software Foundation, Inc.
 This program 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.
 the string should contain a tab, a pseudo-op, and then another tab.",
 const char *, "\t.byte\t")
 DEFHOOKPOD (aligned_op, "*", struct asm_int_op, TARGET_ASM_ALIGNED_INT_OP)
 DEFHOOKPOD (unaligned_op, "*", struct asm_int_op, TARGET_ASM_UNALIGNED_INT_OP)
-/* The maximum number of bytes to skip when applying
-LABEL_ALIGN_AFTER_BARRIER.  */
-DEFHOOK
-(label_align_after_barrier_max_skip,
-"The maximum number of bytes to skip before @var{label} when applying\n\
-@code{LABEL_ALIGN_AFTER_BARRIER}.  This works only if\n\
-@code{ASM_OUTPUT_MAX_SKIP_ALIGN} is defined.",
-int, (rtx_insn *label),
-default_label_align_after_barrier_max_skip)
-/* The maximum number of bytes to skip when applying
-LOOP_ALIGN.  */
-DEFHOOK
-(loop_align_max_skip,
-"The maximum number of bytes to skip when applying @code{LOOP_ALIGN} to\n\
-@var{label}.  This works only if @code{ASM_OUTPUT_MAX_SKIP_ALIGN} is\n\
-defined.",
-int, (rtx_insn *label),
-default_loop_align_max_skip)
-/* The maximum number of bytes to skip when applying
-LABEL_ALIGN.  */
-DEFHOOK
-(label_align_max_skip,
-"The maximum number of bytes to skip when applying @code{LABEL_ALIGN}\n\
-to @var{label}.  This works only if @code{ASM_OUTPUT_MAX_SKIP_ALIGN}\n\
-is defined.",
-int, (rtx_insn *label),
-default_label_align_max_skip)
-/* The maximum number of bytes to skip when applying
-JUMP_ALIGN.  */
-DEFHOOK
-(jump_align_max_skip,
-"The maximum number of bytes to skip before @var{label} when applying\n\
-@code{JUMP_ALIGN}.  This works only if\n\
-@code{ASM_OUTPUT_MAX_SKIP_ALIGN} is defined.",
-int, (rtx_insn *label),
-default_jump_align_max_skip)
 /* Try to output the assembler code for an integer object whose
 value is given by X.  SIZE is the size of the object in bytes and
 ALIGNED_P indicates whether it is aligned.  Return true if
 successful.  Only handles cases for which BYTE_OP, ALIGNED_OP
 and UNALIGNED_OP are NULL.  */
 when the target cannot support (some kinds of) dynamic relocations\n\
 in read-only sections even in executables.",
 int, (void),
 default_reloc_rw_mask)
+/* Return a flag for either generating ADDR_DIF_VEC table
+or ADDR_VEC table for jumps in case of -fPIC/-fPIE.  */
+DEFHOOK
+(generate_pic_addr_diff_vec,
+"Return true to generate ADDR_DIF_VEC table\n\
+or false to generate ADDR_VEC table for jumps in case of -fPIC.\n\
+\n\
+The default version of this function returns true if flag_pic\n\
+equals true and false otherwise",
+bool, (void),
+default_generate_pic_addr_diff_vec)
 /* Return a section for EXP.  It may be a DECL or a constant.  RELOC
 is nonzero if runtime relocations must be applied; bit 1 will be
 set if the runtime relocations require non-local name resolution.
 ALIGN is the required alignment of the data.  */
 DEFHOOK
 void, (FILE *f),
 NULL)
 DEFHOOK
 (output_source_filename,
-"Output COFF information or DWARF debugging information which indicates\
+"Output DWARF debugging information which indicates that filename\
-that filename @var{name} is the current source file to the stdio\
+@var{name} is the current source file to the stdio stream @var{file}.\n\
-stream @var{file}.\n\
 \n\
 This target hook need not be defined if the standard form of output\
 for the file format in use is appropriate.",
 void ,(FILE *file, const char *name),
 default_asm_output_source_filename)
 the hook implementation for how different fusion types are supported.",
 void, (rtx_insn *insn, int max_pri, int *fusion_pri, int *pri), NULL)
 HOOK_VECTOR_END (sched)
-/* Functions relating to OpenMP and Cilk Plus SIMD clones.  */
+/* Functions relating to OpenMP SIMD and __attribute__((simd)) clones.  */
 #undef HOOK_PREFIX
 #define HOOK_PREFIX "TARGET_SIMD_CLONE_"
 HOOK_VECTOR (TARGET_SIMD_CLONE, simd_clone)
 DEFHOOK
 (vector_alignment_reachable,
 "Return true if vector alignment is reachable (by peeling N iterations) for the given scalar type @var{type}.  @var{is_packed} is false if the scalar access using @var{type} is known to be naturally aligned.",
 bool, (const_tree type, bool is_packed),
 default_builtin_vector_alignment_reachable)
-/* Return true if a vector created for vec_perm_const is valid.
+DEFHOOK
-A NULL indicates that all constants are valid permutations.  */
+(vec_perm_const,
-DEFHOOK
+"This hook is used to test whether the target can permute up to two\n\
-(vec_perm_const_ok,
+vectors of mode @var{mode} using the permutation vector @code{sel}, and\n\
-"Return true if a vector created for @code{vec_perm_const} is valid.",
+also to emit such a permutation.  In the former case @var{in0}, @var{in1}\n\
-bool, (machine_mode, vec_perm_indices),
+and @var{out} are all null.  In the latter case @var{in0} and @var{in1} are\n\
+the source vectors and @var{out} is the destination vector; all three are\n\
+registers of mode @var{mode}.  @var{in1} is the same as @var{in0} if\n\
+@var{sel} describes a permutation on one vector instead of two.\n\
+\n\
+Return true if the operation is possible, emitting instructions for it\n\
+if rtxes are provided.\n\
+\n\
+@cindex @code{vec_perm@var{m}} instruction pattern\n\
+If the hook returns false for a mode with multibyte elements, GCC will\n\
+try the equivalent byte operation.  If that also fails, it will try forcing\n\
+the selector into a register and using the @var{vec_perm@var{mode}}\n\
+instruction pattern.  There is no need for the hook to handle these two\n\
+implementation approaches itself.",
+bool, (machine_mode mode, rtx output, rtx in0, rtx in1,
+	const vec_perm_indices &sel),
 NULL)
 /* Return true if the target supports misaligned store/load of a
 specific factor denoted in the third parameter.  The last parameter
 is true if the access is defined in a packed struct.  */
 transformations even in absence of specialized @acronym{SIMD} hardware.",
 machine_mode,
 (scalar_mode mode),
 default_preferred_simd_mode)
+/* Returns the preferred mode for splitting SIMD reductions to.  */
+DEFHOOK
+(split_reduction,
+"This hook should return the preferred mode to split the final reduction\n\
+step on @var{mode} to.  The reduction is then carried out reducing upper\n\
+against lower halves of vectors recursively until the specified mode is\n\
+reached.  The default is @var{mode} which means no splitting.",
+machine_mode,
+(machine_mode),
+default_split_reduction)
 /* Returns a mask of vector sizes to iterate over when auto-vectorizing
 after processing the preferred one derived from preferred_simd_mode.  */
 DEFHOOK
 (autovectorize_vector_sizes,
-"This hook should return a mask of sizes that should be iterated over\n\
+"If the mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE} is not\n\
-after trying to autovectorize using the vector size derived from the\n\
+the only one that is worth considering, this hook should add all suitable\n\
-mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE}.\n\
+vector sizes to @var{sizes}, in order of decreasing preference.  The first\n\
-The default is zero which means to not iterate over other vector sizes.",
+one should be the size of @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE}.\n\
-unsigned int,
+\n\
-(void),
+The hook does not need to do anything if the vector returned by\n\
+@code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE} is the only one relevant\n\
+for autovectorization.  The default implementation does nothing.",
+void,
+(vector_sizes *sizes),
 default_autovectorize_vector_sizes)
 /* Function to get a target mode for a vector mask.  */
 DEFHOOK
 (get_mask_mode,
 \n\
 The default implementation returns the mode of an integer vector that\n\
 is @var{length} bytes long and that contains @var{nunits} elements,\n\
 if such a mode exists.",
 opt_machine_mode,
-(unsigned nunits, unsigned length),
+(poly_uint64 nunits, poly_uint64 length),
 default_get_mask_mode)
+/* Function to say whether a masked operation is expensive when the
+mask is all zeros.  */
+DEFHOOK
+(empty_mask_is_expensive,
+"This hook returns true if masked internal function @var{ifn} (really of\n\
+type @code{internal_fn}) should be considered expensive when the mask is\n\
+all zeros.  GCC can then try to branch around the instruction instead.",
+bool,
+(unsigned ifn),
+default_empty_mask_is_expensive)
 /* Target builtin that implements vector gather operation.  */
 DEFHOOK
 (builtin_gather,
 "Target builtin that implements vector gather operation.  @var{mem_vectype}\n\
 #undef HOOK_PREFIX
 #define HOOK_PREFIX "TARGET_"
 DEFHOOK
+(preferred_else_value,
+"This hook returns the target's preferred final argument for a call\n\
+to conditional internal function @var{ifn} (really of type\n\
+@code{internal_fn}).  @var{type} specifies the return type of the\n\
+function and @var{ops} are the operands to the conditional operation,\n\
+of which there are @var{nops}.\n\
+\n\
+For example, if @var{ifn} is @code{IFN_COND_ADD}, the hook returns\n\
+a value of type @var{type} that should be used when @samp{@var{ops}[0]}\n\
+and @samp{@var{ops}[1]} are conditionally added together.\n\
+\n\
+This hook is only relevant if the target supports conditional patterns\n\
+like @code{cond_add@var{m}}.  The default implementation returns a zero\n\
+constant of type @var{type}.",
+tree,
+(unsigned ifn, tree type, unsigned nops, tree *ops),
+default_preferred_else_value)
+DEFHOOK
 (record_offload_symbol,
 "Used when offloaded functions are seen in the compilation unit and no named\n\
 sections are available.  It is called once for each symbol that must be\n\
 recorded in the offload function and variable table.",
 void, (tree),
 ignored.  This function should return the result of the call to the\n\
 built-in function.",
 rtx,
 (tree exp, rtx target, rtx subtarget, machine_mode mode, int ignore),
 default_expand_builtin)
-DEFHOOK
-(builtin_chkp_function,
-"This hook allows target to redefine built-in functions used by\n\
-Pointer Bounds Checker for code instrumentation.  Hook should return\n\
-fndecl of function implementing generic builtin whose code is\n\
-passed in @var{fcode}.  Currently following built-in functions are\n\
-obtained using this hook:\n\
-@deftypefn {Built-in Function} __bounds_type __chkp_bndmk (const void *@var{lb}, size_t @var{size})\n\
-Function code - BUILT_IN_CHKP_BNDMK.  This built-in function is used\n\
-by Pointer Bounds Checker to create bound values.  @var{lb} holds low\n\
-bound of the resulting bounds.  @var{size} holds size of created bounds.\n\
-@end deftypefn\n\
-\n\
-@deftypefn {Built-in Function} void __chkp_bndstx (const void *@var{ptr}, __bounds_type @var{b}, const void **@var{loc})\n\
-Function code - @code{BUILT_IN_CHKP_BNDSTX}.  This built-in function is used\n\
-by Pointer Bounds Checker to store bounds @var{b} for pointer @var{ptr}\n\
-when @var{ptr} is stored by address @var{loc}.\n\
-@end deftypefn\n\
-\n\
-@deftypefn {Built-in Function} __bounds_type __chkp_bndldx (const void **@var{loc}, const void *@var{ptr})\n\
-Function code - @code{BUILT_IN_CHKP_BNDLDX}.  This built-in function is used\n\
-by Pointer Bounds Checker to get bounds of pointer @var{ptr} loaded by\n\
-address @var{loc}.\n\
-@end deftypefn\n\
-\n\
-@deftypefn {Built-in Function} void __chkp_bndcl (const void *@var{ptr}, __bounds_type @var{b})\n\
-Function code - @code{BUILT_IN_CHKP_BNDCL}.  This built-in function is used\n\
-by Pointer Bounds Checker to perform check for pointer @var{ptr} against\n\
-lower bound of bounds @var{b}.\n\
-@end deftypefn\n\
-\n\
-@deftypefn {Built-in Function} void __chkp_bndcu (const void *@var{ptr}, __bounds_type @var{b})\n\
-Function code - @code{BUILT_IN_CHKP_BNDCU}.  This built-in function is used\n\
-by Pointer Bounds Checker to perform check for pointer @var{ptr} against\n\
-upper bound of bounds @var{b}.\n\
-@end deftypefn\n\
-\n\
-@deftypefn {Built-in Function} __bounds_type __chkp_bndret (void *@var{ptr})\n\
-Function code - @code{BUILT_IN_CHKP_BNDRET}.  This built-in function is used\n\
-by Pointer Bounds Checker to obtain bounds returned by a call statement.\n\
-@var{ptr} passed to built-in is @code{SSA_NAME} returned by the call.\n\
-@end deftypefn\n\
-\n\
-@deftypefn {Built-in Function} __bounds_type __chkp_intersect (__bounds_type @var{b1}, __bounds_type @var{b2})\n\
-Function code - @code{BUILT_IN_CHKP_INTERSECT}.  This built-in function\n\
-returns intersection of bounds @var{b1} and @var{b2}.\n\
-@end deftypefn\n\
-\n\
-@deftypefn {Built-in Function} __bounds_type __chkp_narrow (const void *@var{ptr}, __bounds_type @var{b}, size_t @var{s})\n\
-Function code - @code{BUILT_IN_CHKP_NARROW}.  This built-in function\n\
-returns intersection of bounds @var{b} and\n\
-[@var{ptr}, @var{ptr} + @var{s} - @code{1}].\n\
-@end deftypefn\n\
-\n\
-@deftypefn {Built-in Function} size_t __chkp_sizeof (const void *@var{ptr})\n\
-Function code - @code{BUILT_IN_CHKP_SIZEOF}.  This built-in function\n\
-returns size of object referenced by @var{ptr}. @var{ptr} is always\n\
-@code{ADDR_EXPR} of @code{VAR_DECL}.  This built-in is used by\n\
-Pointer Bounds Checker when bounds of object cannot be computed statically\n\
-(e.g. object has incomplete type).\n\
-@end deftypefn\n\
-\n\
-@deftypefn {Built-in Function} const void *__chkp_extract_lower (__bounds_type @var{b})\n\
-Function code - @code{BUILT_IN_CHKP_EXTRACT_LOWER}.  This built-in function\n\
-returns lower bound of bounds @var{b}.\n\
-@end deftypefn\n\
-\n\
-@deftypefn {Built-in Function} const void *__chkp_extract_upper (__bounds_type @var{b})\n\
-Function code - @code{BUILT_IN_CHKP_EXTRACT_UPPER}.  This built-in function\n\
-returns upper bound of bounds @var{b}.\n\
-@end deftypefn",
-tree, (unsigned fcode),
-default_builtin_chkp_function)
-DEFHOOK
-(chkp_bound_type,
-"Return type to be used for bounds",
-tree, (void),
-default_chkp_bound_type)
-DEFHOOK
-(chkp_bound_mode,
-"Return mode to be used for bounds.",
-machine_mode, (void),
-default_chkp_bound_mode)
-DEFHOOK
-(chkp_make_bounds_constant,
-"Return constant used to statically initialize constant bounds\n\
-with specified lower bound @var{lb} and upper bounds @var{ub}.",
-tree, (HOST_WIDE_INT lb, HOST_WIDE_INT ub),
-default_chkp_make_bounds_constant)
-DEFHOOK
-(chkp_initialize_bounds,
-"Generate a list of statements @var{stmts} to initialize pointer\n\
-bounds variable @var{var} with bounds @var{lb} and @var{ub}.  Return\n\
-the number of generated statements.",
-int, (tree var, tree lb, tree ub, tree *stmts),
-default_chkp_initialize_bounds)
 /* Select a replacement for a target-specific builtin.  This is done
 *before* regular type checking, and so allows the target to
 implement a crude form of function overloading.  The result is a
 complete expression that implements the operation.  PARAMS really
 is correct for most machines.\n\
 \n\
 If @code{TARGET_MODES_TIEABLE_P} returns false for a pair of modes,\n\
 suboptimal code can result if this hook returns true for the corresponding\n\
 mode sizes.  Making this hook return false in such cases may improve things.",
-bool, (unsigned int outprec, unsigned int inprec),
+bool, (poly_uint64 outprec, poly_uint64 inprec),
-hook_bool_uint_uint_true)
+hook_bool_puint64_puint64_true)
 /* If the representation of integral MODE is such that values are
 always sign-extended to a wider mode MODE_REP then return
 SIGN_EXTEND.  Return UNKNOWN otherwise.  */
 /* Note that the return type ought to be RTX_CODE, but that's not
 @code{TARGET_TRULY_NOOP_TRUNCATION} should return false when truncating to\n\
 @code{mode}.",
 int, (scalar_int_mode mode, scalar_int_mode rep_mode),
 default_mode_rep_extended)
+DEFHOOK
+(setjmp_preserves_nonvolatile_regs_p,
+"On some targets, it is assumed that the compiler will spill all pseudos\n\
+that are live across a call to @code{setjmp}, while other targets treat\n\
+@code{setjmp} calls as normal function calls.\n\
+\n\
+This hook returns false if @code{setjmp} calls do not preserve all\n\
+non-volatile registers so that gcc that must spill all pseudos that are\n\
+live across @code{setjmp} calls.  Define this to return true if the\n\
+target does not need to spill all pseudos live across @code{setjmp} calls.\n\
+The default implementation conservatively assumes all pseudos must be\n\
+spilled across @code{setjmp} calls.",
+bool, (void),
+hook_bool_void_false)
 /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))).  */
 DEFHOOK
 (valid_pointer_mode,
 "Define this to return nonzero if the port can handle pointers\n\
 with machine mode @var{mode}.  The default version of this\n\
 constants can be done inline.  The function\n\
 @code{constant_alignment_word_strings} provides such a definition.",
 HOST_WIDE_INT, (const_tree constant, HOST_WIDE_INT basic_align),
 default_constant_alignment)
+DEFHOOK
+(translate_mode_attribute,
+"Define this hook if during mode attribute processing, the port should\n\
+translate machine_mode @var{mode} to another mode.  For example, rs6000's\n\
+@code{KFmode}, when it is the same as @code{TFmode}.\n\
+\n\
+The default version of the hook returns that mode that was passed in.",
+machine_mode, (machine_mode mode),
+default_translate_mode_attribute)
 /* 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.  */
 DEFHOOK
 (scalar_mode_supported_p,
 require natural alignment for vector types.  The alignment returned by\n\
 this hook must be a power-of-two multiple of the default alignment of\n\
 the vector element type.",
 HOST_WIDE_INT, (const_tree type),
 default_vector_alignment)
+DEFHOOK
+(array_mode,
+"Return the mode that GCC should use for an array that has\n\
+@var{nelems} elements, with each element having mode @var{mode}.\n\
+Return no mode if the target has no special requirements.  In the\n\
+latter case, GCC looks for an integer mode of the appropriate size\n\
+if available and uses BLKmode otherwise.  Usually the search for the\n\
+integer mode is limited to @code{MAX_FIXED_MODE_SIZE}, but the\n\
+@code{TARGET_ARRAY_MODE_SUPPORTED_P} hook allows a larger mode to be\n\
+used in specific cases.\n\
+\n\
+The main use of this hook is to specify that an array of vectors should\n\
+also have a vector mode.  The default implementation returns no mode.",
+opt_machine_mode, (machine_mode mode, unsigned HOST_WIDE_INT nelems),
+hook_optmode_mode_uhwi_none)
 /* True if we should try to use a scalar mode to represent an array,
 overriding the usual MAX_FIXED_MODE limit.  */
 DEFHOOK
 (array_mode_supported_p,
 ISO/IEC TS 18661-3:2015; that is, @var{n} is one of 32, 64, 128, or,\n\
 if @var{extended} is false, 16 or greater than 128 and a multiple of 32.",
 opt_scalar_float_mode, (int n, bool extended),
 default_floatn_mode)
+DEFHOOK
+(floatn_builtin_p,
+"Define this to return true if the @code{_Float@var{n}} and\n\
+@code{_Float@var{n}x} built-in functions should implicitly enable the\n\
+built-in function without the @code{__builtin_} prefix in addition to the\n\
+normal built-in function with the @code{__builtin_} prefix.  The default is\n\
+to only enable built-in functions without the @code{__builtin_} prefix for\n\
+the GNU C langauge.  In strict ANSI/ISO mode, the built-in function without\n\
+the @code{__builtin_} prefix is not enabled.  The argument @code{FUNC} is the\n\
+@code{enum built_in_function} id of the function to be enabled.",
+bool, (int func),
+default_floatn_builtin_p)
 /* Compute cost of moving data from a register of class FROM to one of
 TO, using MODE.  */
 DEFHOOK
 (register_move_cost,
 "This target hook should return the cost of moving data of mode @var{mode}\n\
 "This hook returns true if the instruction sequence @code{seq} is a good\n\
 candidate as a replacement for the if-convertible sequence described in\n\
 @code{if_info}.",
 bool, (rtx_insn *seq, struct noce_if_info *if_info),
 default_noce_conversion_profitable_p)
+DEFHOOK
+(estimated_poly_value,
+"Return an estimate of the runtime value of @var{val}, for use in\n\
+things like cost calculations or profiling frequencies.  The default\n\
+implementation returns the lowest possible value of @var{val}.",
+HOST_WIDE_INT, (poly_int64 val),
+default_estimated_poly_value)
 /* Permit speculative instructions in delay slots during delayed-branch
 scheduling.  */
 DEFHOOK
 (no_speculation_in_delay_slots_p,
 to let the backend emit the call frame instructions.  @var{label} is\n\
 the CFI label attached to the insn, @var{pattern} is the pattern of\n\
 the insn and @var{index} is @code{UNSPEC_INDEX} or @code{UNSPECV_INDEX}.",
 void, (const char *label, rtx pattern, int index), NULL)
+DEFHOOK
+(dwarf_poly_indeterminate_value,
+"Express the value of @code{poly_int} indeterminate @var{i} as a DWARF\n\
+expression, with @var{i} counting from 1.  Return the number of a DWARF\n\
+register @var{R} and set @samp{*@var{factor}} and @samp{*@var{offset}} such\n\
+that the value of the indeterminate is:\n\
+@smallexample\n\
+value_of(@var{R}) / @var{factor} - @var{offset}\n\
+@end smallexample\n\
+\n\
+A target only needs to define this hook if it sets\n\
+@samp{NUM_POLY_INT_COEFFS} to a value greater than 1.",
+unsigned int, (unsigned int i, unsigned int *factor, int *offset),
+default_dwarf_poly_indeterminate_value)
 /* ??? Documenting this hook requires a GFDL license grant.  */
 DEFHOOK_UNDOC
 (stdarg_optimize_hook,
 "Perform architecture specific checking of statements gimplified\
 from @code{VA_ARG_EXPR}.  @var{stmt} is the statement.  Returns true if\
 (stack_protect_runtime_enabled_p,
 "Returns true if the target wants GCC's default stack protect runtime support,\
 otherwise return false.  The default implementation always returns true.",
 bool, (void),
 hook_bool_void_true)
+DEFHOOK
+(have_speculation_safe_value,
+"This hook is used to determine the level of target support for\n\
+@code{__builtin_speculation_safe_value}.  If called with an argument\n\
+of false, it returns true if the target has been modified to support\n\
+this builtin.  If called with an argument of true, it returns true\n\
+if the target requires active mitigation execution might be speculative.\n\
+\n\
+The default implementation returns false if the target does not define\n\
+a pattern named @code{speculation_barrier}.  Else it returns true\n\
+for the first case and whether the pattern is enabled for the current\n\
+compilation for the second case.\n\
+\n\
+For targets that have no processors that can execute instructions\n\
+speculatively an alternative implemenation of this hook is available:\n\
+simply redefine this hook to @code{speculation_safe_value_not_needed}\n\
+along with your other target hooks.",
+bool, (bool active), default_have_speculation_safe_value)
+DEFHOOK
+(speculation_safe_value,
+"This target hook can be used to generate a target-specific code\n\
+sequence that implements the @code{__builtin_speculation_safe_value}\n\
+built-in function.  The function must always return @var{val} in\n\
+@var{result} in mode @var{mode} when the cpu is not executing\n\
+speculatively, but must never return that when speculating until it\n\
+is known that the speculation will not be unwound.  The hook supports\n\
+two primary mechanisms for implementing the requirements.  The first\n\
+is to emit a speculation barrier which forces the processor to wait\n\
+until all prior speculative operations have been resolved; the second\n\
+is to use a target-specific mechanism that can track the speculation\n\
+state and to return @var{failval} if it can determine that\n\
+speculation must be unwound at a later time.\n\
+\n\
+The default implementation simply copies @var{val} to @var{result} and\n\
+emits a @code{speculation_barrier} instruction if that is defined.",
+rtx, (machine_mode mode, rtx result, rtx val, rtx failval),
+default_speculation_safe_value)
 DEFHOOK
 (can_use_doloop_p,
 "Return true if it is possible to use low-overhead loops (@code{doloop_end}\n\
 and @code{doloop_begin}) for a particular loop.  @var{iterations} gives the\n\
 aggregate data types, because these are returned in another way.  See\n\
 @code{TARGET_STRUCT_VALUE_RTX} and related macros, below.",
 rtx, (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing),
 default_function_value)
-/* Return the rtx for bounds of returned pointer.  */
-DEFHOOK
-(chkp_function_value_bounds,
-"Define this to return an RTX representing the place where a function\n\
-returns bounds for returned pointers.  Arguments meaning is similar to\n\
-@code{TARGET_FUNCTION_VALUE}.",
-rtx, (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing),
-default_chkp_function_value_bounds)
 /* Return the rtx for the result of a libcall of mode MODE,
 calling the function FN_NAME.  */
 DEFHOOK
 (libcall_value,
 "Define this hook if the back-end needs to know the name of the libcall\n\
 If this hook is not defined, @var{addr} will be used for function calls.",
 rtx, (rtx addr), NULL)
 DEFHOOKPOD
 (custom_function_descriptors,
-"This hook should be defined to a power of 2 if the target will benefit\n\
+"If the target can use GCC's generic descriptor mechanism for nested\n\
-from the use of custom descriptors for nested functions instead of the\n\
+functions, define this hook to a power of 2 representing an unused bit\n\
-standard trampolines.  Such descriptors are created at run time on the\n\
+in function pointers which can be used to differentiate descriptors at\n\
-stack and made up of data only, but they are non-standard so the generated\n\
+run time.  This value gives the number of bytes by which descriptor\n\
-code must be prepared to deal with them.  This hook should be defined to 0\n\
+pointers are misaligned compared to function pointers.  For example, on\n\
-if the target uses function descriptors for its standard calling sequence,\n\
+targets that require functions to be aligned to a 4-byte boundary, a\n\
-like for example HP-PA or IA-64.  Using descriptors for nested functions\n\
+value of either 1 or 2 is appropriate unless the architecture already\n\
+reserves the bit for another purpose, such as on ARM.\n\
+\n\
+Define this hook to 0 if the target implements ABI support for\n\
+function descriptors in its standard calling sequence, like for example\n\
+HPPA or IA-64.\n\
+\n\
+Using descriptors for nested functions\n\
 eliminates the need for trampolines that reside on the stack and require\n\
-it to be made executable.\n\
+it to be made executable.",\
-\n\
-The value of the macro is used to parameterize the run-time identification\n\
-scheme implemented to distinguish descriptors from function addresses: it\n\
-gives the number of bytes by which their address is misaligned compared\n\
-with function addresses.  The value of 1 will generally work, unless it is\n\
-already reserved by the target for another purpose, like for example on ARM.",\
 int, -1)
 /* Return the number of bytes of its own arguments that a function
 pops on returning, or 0 if the function pops no arguments and the
 caller must therefore pop them all after the function returns.  */
 convention is available in which functions that take a fixed number of\n\
 arguments pop them but other functions (such as @code{printf}) pop\n\
 nothing (the caller pops all).  When this convention is in use,\n\
 @var{funtype} is examined to determine whether a function takes a fixed\n\
 number of arguments.",
-int, (tree fundecl, tree funtype, int size),
+poly_int64, (tree fundecl, tree funtype, poly_int64 size),
 default_return_pops_args)
 /* Return a mode wide enough to copy any function value that might be
 returned.  */
 DEFHOOK
 (get_raw_result_mode,
 "This target hook returns the mode to be used when accessing raw return\
 registers in @code{__builtin_return}.  Define this macro if the value\
 in @var{reg_raw_mode} is not correct.",
-machine_mode, (int regno),
+fixed_size_mode, (int regno),
 default_get_reg_raw_mode)
 /* Return a mode wide enough to copy any argument value that might be
 passed.  */
 DEFHOOK
 (get_raw_arg_mode,
 "This target hook returns the mode to be used when accessing raw argument\
 registers in @code{__builtin_apply_args}.  Define this macro if the value\
 in @var{reg_raw_mode} is not correct.",
-machine_mode, (int regno),
+fixed_size_mode, (int regno),
 default_get_reg_raw_mode)
+/* Return true if a type is an empty record.  */
+DEFHOOK
+(empty_record_p,
+"This target hook returns true if the type is an empty record.  The default\n\
+is to return @code{false}.",
+bool, (const_tree type),
+hook_bool_const_tree_false)
+/* Warn about the change in empty class parameter passing ABI.  */
+DEFHOOK
+(warn_parameter_passing_abi,
+"This target hook warns about the change in empty class parameter passing\n\
+ABI.",
+void, (cumulative_args_t ca, tree type),
+hook_void_CUMULATIVE_ARGS_tree)
 HOOK_VECTOR_END (calls)
 DEFHOOK
 (use_pseudo_pic_reg,
 reg_class_t,
 (rtx x, reg_class_t rclass),
 default_preferred_output_reload_class)
 DEFHOOK
+(select_early_remat_modes,
+"On some targets, certain modes cannot be held in registers around a\n\
+standard ABI call and are relatively expensive to spill to the stack.\n\
+The early rematerialization pass can help in such cases by aggressively\n\
+recomputing values after calls, so that they don't need to be spilled.\n\
+\n\
+This hook returns the set of such modes by setting the associated bits\n\
+in @var{modes}.  The default implementation selects no modes, which has\n\
+the effect of disabling the early rematerialization pass.",
+void, (sbitmap modes),
+default_select_early_remat_modes)
+DEFHOOK
 (class_likely_spilled_p,
 "A target hook which returns @code{true} if pseudos that have been assigned\n\
 to registers of class @var{rclass} would likely be spilled because\n\
 registers of @var{rclass} are needed for spill registers.\n\
 \n\
 /* This target hook allows the backend to legitimize base plus
 displacement addressing.  */
 DEFHOOK
 (legitimize_address_displacement,
-"A target hook which returns @code{true} if *@var{disp} is\n\
+"This hook tries to split address offset @var{orig_offset} into\n\
-legitimezed to valid address displacement with subtracting *@var{offset}\n\
+two parts: one that should be added to the base address to create\n\
-at memory mode @var{mode}.\n\
+a local anchor point, and an additional offset that can be applied\n\
-The default version of this target hook returns @code{false}.\n\
+to the anchor to address a value of mode @var{mode}.  The idea is that\n\
-This hook will benefit machines with limited base plus displacement\n\
+the local anchor could be shared by other accesses to nearby locations.\n\
-addressing.",
+\n\
-bool, (rtx *disp, rtx *offset, machine_mode mode),
+The hook returns true if it succeeds, storing the offset of the\n\
+anchor from the base in @var{offset1} and the offset of the final address\n\
+from the anchor in @var{offset2}.  The default implementation returns false.",
+bool, (rtx *offset1, rtx *offset2, poly_int64 orig_offset, machine_mode mode),
 default_legitimize_address_displacement)
 /* This target hook allows the backend to perform additional
 processing while initializing for variable expansion.  */
 DEFHOOK
 these registers when the target switches are opposed to them.)",
 void, (void),
 hook_void_void)
 DEFHOOK
-(stack_clash_protection_final_dynamic_probe,
+(stack_clash_protection_alloca_probe_range,
-"Some targets make optimistic assumptions about the state of stack probing when they emit their prologues.  On such targets a probe into the end of any dynamically allocated space is likely required for safety against stack clash style attacks.  Define this variable to return nonzero if such a probe is required or zero otherwise.  You need not define this macro if it would always have the value zero.",
+"Some targets have an ABI defined interval for which no probing needs to be done.\n\
-bool, (rtx residual),
+When a probe does need to be done this same interval is used as the probe distance \
-default_stack_clash_protection_final_dynamic_probe)
+up when doing stack clash protection for alloca.\n\
+On such targets this value can be set to override the default probing up interval.\n\
+Define this variable to return nonzero if such a probe range is required or zero otherwise.  \
+Defining this hook also requires your functions which make use of alloca to have at least 8 byes\
+of outgoing arguments.  If this is not the case the stack will be corrupted.\n\
+You need not define this macro if it would always have the value zero.",
+HOST_WIDE_INT, (void),
+default_stack_clash_protection_alloca_probe_range)
 /* Functions specific to the C family of frontends.  */
 #undef HOOK_PREFIX
 #define HOOK_PREFIX "TARGET_C_"
 A target may return @code{UI_TARGET} if it has ABI specified unwind tables.\n\
 This will suppress generation of the normal debug frame unwind information.",
 enum unwind_info_type, (void),
 default_debug_unwind_info)
+DEFHOOK
+(reset_location_view, "\
+This hook, if defined, enables -ginternal-reset-location-views, and\n\
+uses its result to override cases in which the estimated min insn\n\
+length might be nonzero even when a PC advance (i.e., a view reset)\n\
+cannot be taken for granted.\n\
+\n\
+If the hook is defined, it must return a positive value to indicate\n\
+the insn definitely advances the PC, and so the view number can be\n\
+safely assumed to be reset; a negative value to mean the insn\n\
+definitely does not advance the PC, and os the view number must not\n\
+be reset; or zero to decide based on the estimated insn length.\n\
+\n\
+If insn length is to be regarded as reliable, set the hook to\n\
+@code{hook_int_rtx_insn_0}.",
+int, (rtx_insn *), NULL)
 /* The code parameter should be of type enum rtx_code but this is not
 defined at this time.  */
 DEFHOOK
 (canonicalize_comparison,
 "On some machines not all possible comparisons are defined, but you can\n\

Mercurial > hg > CbC > CbC_gcc

comparison gcc/target.def @ 131:84e7813d76e9