diff options
Diffstat (limited to 'gcc/doc/tm.texi')
| -rw-r--r-- | gcc/doc/tm.texi | 161 |
1 files changed, 137 insertions, 24 deletions
diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index a96700c..bbb1182 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -37,6 +37,8 @@ through the macros defined in the @file{.h} file. * Trampolines:: Code set up at run time to enter a nested function. * Library Calls:: Controlling how library routines are implicitly called. * Addressing Modes:: Defining addressing modes valid for memory operands. +* Vectorization:: Controlling how the vectorizer operates. +* OpenMP and OpenACC:: Defining how OpenMP and OpenACC features should work. * Anchored Addresses:: Defining how @option{-fsection-anchors} should work. * Condition Code:: Defining how insns update the condition code. * Costs:: Defining relative costs of different operations. @@ -54,6 +56,7 @@ through the macros defined in the @file{.h} file. * C++ ABI:: Controlling C++ ABI changes. * D Language and ABI:: Controlling D ABI changes. * Rust Language and ABI:: Controlling Rust ABI changes. +* JIT Language and ABI:: JIT ABI parameters * Named Address Spaces:: Adding support for named address spaces * Misc:: Everything else. @end menu @@ -124,6 +127,14 @@ If targets initialize @code{targetrustm} themselves, they should set @code{target_has_targetrustm=yes} in @file{config.gcc}; otherwise a default definition is used. +Similarly, there is a @code{targetjitm} variable for hooks that are +specific to the jit front end, documented as ``JIT Target Hook''. +This is declared in @file{jit/jit-target.h}, the initializer +@code{TARGETJITM_INITIALIZER} in @file{jit/jit-target-def.h}. If targets +initialize @code{targetjitm} themselves, they should set +@code{target_has_targetjitm=yes} in @file{config.gcc}; otherwise a default +definition is used. + @node Driver @section Controlling the Compilation Driver, @file{gcc} @cindex driver @@ -1424,10 +1435,10 @@ the smaller of @var{computed} and @code{BIGGEST_ALIGNMENT} @defmac MAX_FIXED_MODE_SIZE An integer expression for the size in bits of the largest integer -machine mode that should actually be used. All integer machine modes of -this size or smaller can be used for structures and unions with the -appropriate sizes. If this macro is undefined, @code{GET_MODE_BITSIZE -(DImode)} is assumed. +machine mode that should actually be used by GCC internally. +All integer machine modes of this size or smaller can be used for +structures and unions with the appropriate sizes. If this macro is +undefined, @code{MAX (BITS_PER_WORD * 2, 64)} is assumed. @end defmac @defmac STACK_SAVEAREA_MODE (@var{save_level}) @@ -1814,6 +1825,7 @@ int}. @defmacx UINT_FAST64_TYPE @defmacx INTPTR_TYPE @defmacx UINTPTR_TYPE +@defmacx PID_TYPE C expressions for the standard types @code{sig_atomic_t}, @code{int8_t}, @code{int16_t}, @code{int32_t}, @code{int64_t}, @code{uint8_t}, @code{uint16_t}, @code{uint32_t}, @code{uint64_t}, @@ -1822,8 +1834,8 @@ C expressions for the standard types @code{sig_atomic_t}, @code{uint_least32_t}, @code{uint_least64_t}, @code{int_fast8_t}, @code{int_fast16_t}, @code{int_fast32_t}, @code{int_fast64_t}, @code{uint_fast8_t}, @code{uint_fast16_t}, @code{uint_fast32_t}, -@code{uint_fast64_t}, @code{intptr_t}, and @code{uintptr_t}. See -@code{SIZE_TYPE} above for more information. +@code{uint_fast64_t}, @code{intptr_t}, and @code{uintptr_t} and the +built-in type @code{pid_t}. See @code{SIZE_TYPE} above for more information. If any of these macros evaluates to a null pointer, the corresponding type is not supported; if GCC is configured to provide @@ -4774,10 +4786,6 @@ that element as the canonical location and ignore the others. The m68k port uses this type of @code{parallel} to return pointers in both @samp{%a0} (the canonical location) and @samp{%d0}. -If @code{TARGET_PROMOTE_FUNCTION_RETURN} returns true, you must apply -the same promotion rules specified in @code{PROMOTE_MODE} if -@var{valtype} is a scalar type. - If the precise function being called is known, @var{func} is a tree node (@code{FUNCTION_DECL}) for it; otherwise, @var{func} is a null pointer. This makes it possible to use a different value-returning @@ -6286,6 +6294,10 @@ reciprocal of the machine-specific builtin function @var{fndecl}, or @code{NULL_TREE} if such a function is not available. @end deftypefn +@node Vectorization +@section Vectorization +@cindex Vectorization + @deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD (void) This hook should return the DECL of a function @var{f} that given an address @var{addr} as an argument returns a mask @var{m} that can be @@ -6386,12 +6398,14 @@ return type of the vectorized function shall be of vector type @var{vec_type_out} and the argument types should be @var{vec_type_in}. @end deftypefn -@deftypefn {Target Hook} bool TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT (machine_mode @var{mode}, const_tree @var{type}, int @var{misalignment}, bool @var{is_packed}) +@deftypefn {Target Hook} bool TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT (machine_mode @var{mode}, int @var{misalignment}, bool @var{is_packed}, bool @var{is_gather_scatter}) This hook should return true if the target supports misaligned vector store/load of a specific factor denoted in the @var{misalignment} -parameter. The vector store/load should be of machine mode @var{mode} and -the elements in the vectors should be of type @var{type}. @var{is_packed} -parameter is true if the memory access is defined in a packed struct. +parameter. The vector store/load should be of machine mode @var{mode}. +The @var{is_packed} parameter is true if the original memory access is +not naturally aligned. @var{is_gather_scatter} is true if the +load/store is a gather or scatter. In that case misalignment +denotes the misalignment of @var{mode}'s element mode. @end deftypefn @deftypefn {Target Hook} machine_mode TARGET_VECTORIZE_PREFERRED_SIMD_MODE (scalar_mode @var{mode}) @@ -6515,6 +6529,19 @@ The default is @code{NULL_TREE} which means to not vectorize scatter stores. @end deftypefn +@deftypefn {Target Hook} bool TARGET_VECTORIZE_PREFER_GATHER_SCATTER (machine_mode @var{mode}, int @var{scale}, unsigned int @var{group_size}) +This hook returns TRUE if gather loads or scatter stores are cheaper on +this target than a sequence of elementwise loads or stores. The @var{mode} +and @var{scale} correspond to the @code{gather_load} and +@code{scatter_store} instruction patterns. The @var{group_size} is the +number of scalar elements in each scalar loop iteration that are to be +combined into the vector. +@end deftypefn + +@node OpenMP and OpenACC +@section OpenMP and OpenACC +@cindex OpenMP and OpenACC + @deftypefn {Target Hook} int TARGET_SIMD_CLONE_COMPUTE_VECSIZE_AND_SIMDLEN (struct cgraph_node *@var{}, struct cgraph_simd_clone *@var{}, @var{tree}, @var{int}, @var{bool}) This hook should set @var{vecsize_mangle}, @var{vecsize_int}, @var{vecsize_float} fields in @var{simd_clone} structure pointed by @var{clone_info} argument and also @@ -6602,6 +6629,20 @@ like @code{cond_add@var{m}}. The default implementation returns a zero constant of type @var{type}. @end deftypefn +@deftypefn {Target Hook} bool TARGET_INSTRUCTION_SELECTION (function *@var{fun}, gimple_stmt_iterator *@var{gsi}) +This hook allows a target to perform custom instruction selection for an +instruction or sequence of instructions before expand to allow expansion to +generate more efficient code. + +@var{fun} is the current function being considered and @var{gsi} is the +iterator pointing to the current instruction being optimized. The default +implementation does not do any rewriting and returns false. The result of +the function should be whether any changes were made to the CFG or not. If a +change was made then the @var{gsi} should be left at the same position as at +the function start. The caller is allowed to change the CFG at any point +before the current statement @var{gsi} is pointing to but not afterwards. +@end deftypefn + @deftypefn {Target Hook} tree TARGET_GOACC_ADJUST_PRIVATE_DECL (location_t @var{loc}, tree @var{var}, int @var{level}) This hook, if defined, is used by accelerator target back-ends to adjust OpenACC variable declarations that should be made private to the given @@ -9562,9 +9603,10 @@ It is false if we must use @command{collect2}. @deftypevr {Target Hook} bool TARGET_DTORS_FROM_CXA_ATEXIT This value is true if the target wants destructors to be queued to be -run from __cxa_atexit. If this is the case then, for each priority level, -a new constructor will be entered that registers the destructors for that -level with __cxa_atexit (and there will be no destructors emitted). +run from @code{__cxa_atexit}. If this is the case then, for each +priority level, a new constructor will be entered that registers the +destructors for that level with @code{__cxa_atexit} (and there will be +no destructors emitted). It is false the method implied by @code{have_ctors_dtors} is used. @end deftypevr @@ -10907,6 +10949,16 @@ the function declaration to hold a pointer to a target-specific @code{struct cl_target_option} structure. @end deftypefn +@defmac TARGET_HAS_FMV_TARGET_ATTRIBUTE +Define this macro to zero to use @code{target_version} attributes for function +multiversioning (FMV) rather than @code{target} attributes. + +Targets using @code{target_version} attributes will also have +"target_version" FMV semantics, which allow for FMV sets defined across TU's +and using a combination of @code{target_version} and @code{target_clones} +attributed declarations in the definition of a FMV function set. +@end defmac + @defmac TARGET_CLONES_ATTR_SEPARATOR Define this char-typed macro to select a character that separates each target specific attributes from the @code{attribute(target_clones("..."))} @@ -10960,12 +11012,28 @@ changed via the optimize attribute or pragma, see @code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE} @end deftypefn -@deftypefn {Target Hook} bool TARGET_OPTION_FUNCTION_VERSIONS (tree @var{decl1}, tree @var{decl2}) -This target hook returns @code{true} if @var{DECL1} and @var{DECL2} are -versions of the same function. @var{DECL1} and @var{DECL2} are function -versions if and only if they have the same function signature and -different target specific attributes, that is, they are compiled for -different target machines. +@deftypefn {Target Hook} bool TARGET_OPTION_SAME_FUNCTION_VERSIONS (string_slice @var{fn1}, string_slice @var{fn2}) +This target hook returns @code{true} if the target/target-version strings +@var{fn1} and @var{fn2} imply the same function version. +@end deftypefn + +@deftypefn {Target Hook} bool TARGET_OPTION_FUNCTIONS_B_RESOLVABLE_FROM_A (tree @var{decl_a}, tree @var{decl_v}, tree @var{base}) +@var{decl_b} is a function declaration with a function multi-versioning +(FMV) attribute; this attribute is either @code{target} or +@code{target_version}, depending on @code{TARGET_HAS_FMV_TARGET_ATTRIBUTE}. +@var{decl_a} is a function declaration that may or may not have an FMV +attribute. + +Return true if we have enough information to determine that the +requirements of @var{decl_b}'s FMV attribute are met whenever @var{decl_a} +is executed, given that the target supports all features required by +function declaration @var{base}. + +The default implementation just checks whether @var{decl_a} has the same +FMV attribute as @var{decl_b}. This is conservatively correct, +but ports can do better by taking the relationships between architecture +features into account. For example, on AArch64, @code{sve} is present +whenever @code{sve2} is present. @end deftypefn @deftypefn {Target Hook} bool TARGET_CAN_INLINE_P (tree @var{caller}, tree @var{callee}) @@ -11352,6 +11420,17 @@ Similar to @code{TARGET_RUST_CPU_INFO}, but is used for configuration info relating to the target operating system. @end deftypefn +@node JIT Language and ABI +@section JIT ABI parameters +@cindex parameters, jit abi + +@deftypefn {JIT Target Hook} void TARGET_JIT_REGISTER_CPU_TARGET_INFO (void) +Register all target information keys relating to the target CPU using the +function @code{jit_add_target_info}, which takes a key and a value. The +keys added by this hook are made available at compile time by calling +get_target_info. +@end deftypefn + @node Named Address Spaces @section Adding support for named address spaces @cindex named address spaces @@ -11468,6 +11547,31 @@ the address space as registered with @code{c_register_addr_space}. The default implementation does nothing. @end deftypefn +@deftypefn {Target Hook} addr_space_t TARGET_ADDR_SPACE_FOR_ARTIFICIAL_RODATA (tree @var{type}, enum artificial_rodata @var{purpose}) +Define this hook to return a named address space to be used for +@var{type}, usually the type of an artificial lookup-table that would +reside in @code{.rodata} and in the generic address space. + +The hook can be used to put compiler-generated, artificial lookup tables in +static storage into a non-generic address space when it is better suited +than the generic address space. +The compiler will generate all accesses to the respective data +so that all associated accesses will also use the specified address space +and pointer mode. + +@var{type} is the type of the lookup table. @var{purpose} specifies +the purpose of the lookup table. It is one of: +@table @code +@item ARTIFICIAL_RODATA_CSWITCH +@file{tree-switch-conversion.cc} lowered a GIMPLE_SWITCH expressions +to something more efficient than a jump table. +@item ARTIFICIAL_RODATA_CRC +@file{gimple-crc-optimization.cc} optimized a CRC computation by +using a polynomial lookup table. +@end table +The default implementation of the hook returns @code{ADDR_SPACE_GENERIC}. +@end deftypefn + @node Misc @section Miscellaneous Parameters @cindex parameters, miscellaneous @@ -12272,6 +12376,15 @@ function version at run-time for a given set of function versions. body must be generated. @end deftypefn +@deftypefn {Target Hook} bool TARGET_CHECK_TARGET_CLONE_VERSION (string_slice @var{str}, location_t *@var{loc}) +This hook is used to check if a version specified in a @code{target_clones} +annotation is valid. @var{str} is the version to be considered. +If @var{loc} is not @code{NULL} then emit warnings for invalid versions at +that location. Otherwise emit no diagnostics. +Returns @code{true} if @var{str} is a valid version string, and @code{false} +otherwise +@end deftypefn + @deftypefn {Target Hook} bool TARGET_PREDICT_DOLOOP_P (class loop *@var{loop}) Return true if we can predict it is possible to use a low-overhead loop for a particular loop. The parameter @var{loop} is a pointer to the loop. @@ -12864,7 +12977,7 @@ At preset, this feature does not support address spaces. It also requires @code{Pmode} to be the same as @code{ptr_mode}. @end deftypefn -@deftypefn {Target Hook} uint8_t TARGET_MEMTAG_TAG_SIZE () +@deftypefn {Target Hook} uint8_t TARGET_MEMTAG_TAG_BITSIZE () Return the size of a tag (in bits) for this platform. The default returns 8. |