public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc r13-3994] Revert "sphinx: add tm.rst.in"
@ 2022-11-14 8:39 Martin Liska
0 siblings, 0 replies; only message in thread
From: Martin Liska @ 2022-11-14 8:39 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:ef0879e3b4243293daf7e5dcf2c20e013d1c7037
commit r13-3994-gef0879e3b4243293daf7e5dcf2c20e013d1c7037
Author: Martin Liska <mliska@suse.cz>
Date: Sun Nov 13 21:59:37 2022 +0100
Revert "sphinx: add tm.rst.in"
This reverts commit 564a805f9f08b4346a854ab8dca2e5b561a7a28e.
Diff:
---
gcc/doc/gccint/target-macros/tm.rst.in | 6903 --------------------------------
1 file changed, 6903 deletions(-)
diff --git a/gcc/doc/gccint/target-macros/tm.rst.in b/gcc/doc/gccint/target-macros/tm.rst.in
deleted file mode 100644
index 17fc9e1b0aa..00000000000
--- a/gcc/doc/gccint/target-macros/tm.rst.in
+++ /dev/null
@@ -1,6903 +0,0 @@
-[TARGET_ASM_OPEN_PAREN]
-.. c:var:: const char * TARGET_ASM_OPEN_PAREN
-
- These target hooks are C string constants, describing the syntax in the
- assembler for grouping arithmetic expressions. If not overridden, they
- default to normal parentheses, which is correct for most assemblers.
-
-[TARGET_ASM_OPEN_PAREN]
-
-[TARGET_ASM_BYTE_OP]
-.. c:var:: const char * TARGET_ASM_BYTE_OP
-
- These hooks specify assembly directives for creating certain kinds
- of integer object. The ``TARGET_ASM_BYTE_OP`` directive creates a
- byte-sized object, the ``TARGET_ASM_ALIGNED_HI_OP`` one creates an
- aligned two-byte object, and so on. Any of the hooks may be
- ``NULL``, indicating that no suitable directive is available.
-
- The compiler will print these strings at the start of a new line,
- followed immediately by the object's initial value. In most cases,
- the string should contain a tab, a pseudo-op, and then another tab.
-
-[TARGET_ASM_BYTE_OP]
-
-[TARGET_ASM_INTEGER]
-.. function:: bool TARGET_ASM_INTEGER (rtx x, unsigned int size, int aligned_p)
-
- The ``assemble_integer`` function uses this hook to output an
- integer object. :samp:`{x}` is the object's value, :samp:`{size}` is its size
- in bytes and :samp:`{aligned_p}` indicates whether it is aligned. The
- function should return ``true`` if it was able to output the
- object. If it returns false, ``assemble_integer`` will try to
- split the object into smaller parts.
-
- The default implementation of this hook will use the
- ``TARGET_ASM_BYTE_OP`` family of strings, returning ``false``
- when the relevant string is ``NULL``.
-
-[TARGET_ASM_INTEGER]
-
-[TARGET_ASM_POST_CFI_STARTPROC]
-.. function:: void TARGET_ASM_POST_CFI_STARTPROC (FILE *, tree)
-
- This target hook is used to emit assembly strings required by the target
- after the .cfi_startproc directive. The first argument is the file stream to
- write the strings to and the second argument is the function's declaration. The
- expected use is to add more .cfi_\* directives.
-
- The default is to not output any assembly strings.
-
-[TARGET_ASM_POST_CFI_STARTPROC]
-
-[TARGET_ASM_DECL_END]
-.. function:: void TARGET_ASM_DECL_END (void)
-
- Define this hook if the target assembler requires a special marker to
- terminate an initialized variable declaration.
-
-[TARGET_ASM_DECL_END]
-
-[TARGET_ASM_GLOBALIZE_LABEL]
-.. function:: void TARGET_ASM_GLOBALIZE_LABEL (FILE *stream, const char *name)
-
- This target hook is a function to output to the stdio stream
- :samp:`{stream}` some commands that will make the label :samp:`{name}` global;
- that is, available for reference from other files.
-
- The default implementation relies on a proper definition of
- ``GLOBAL_ASM_OP``.
-
-[TARGET_ASM_GLOBALIZE_LABEL]
-
-[TARGET_ASM_GLOBALIZE_DECL_NAME]
-.. function:: void TARGET_ASM_GLOBALIZE_DECL_NAME (FILE *stream, tree decl)
-
- This target hook is a function to output to the stdio stream
- :samp:`{stream}` some commands that will make the name associated with :samp:`{decl}`
- global; that is, available for reference from other files.
-
- The default implementation uses the TARGET_ASM_GLOBALIZE_LABEL target hook.
-
-[TARGET_ASM_GLOBALIZE_DECL_NAME]
-
-[TARGET_ASM_ASSEMBLE_UNDEFINED_DECL]
-.. function:: void TARGET_ASM_ASSEMBLE_UNDEFINED_DECL (FILE *stream, const char *name, const_tree decl)
-
- This target hook is a function to output to the stdio stream
- :samp:`{stream}` some commands that will declare the name associated with
- :samp:`{decl}` which is not defined in the current translation unit. Most
- assemblers do not require anything to be output in this case.
-
-[TARGET_ASM_ASSEMBLE_UNDEFINED_DECL]
-
-[TARGET_ASM_EMIT_UNWIND_LABEL]
-.. function:: void TARGET_ASM_EMIT_UNWIND_LABEL (FILE *stream, tree decl, int for_eh, int empty)
-
- This target hook emits a label at the beginning of each FDE. It
- should be defined on targets where FDEs need special labels, and it
- should write the appropriate label, for the FDE associated with the
- function declaration :samp:`{decl}`, to the stdio stream :samp:`{stream}`.
- The third argument, :samp:`{for_eh}`, is a boolean: true if this is for an
- exception table. The fourth argument, :samp:`{empty}`, is a boolean:
- true if this is a placeholder label for an omitted FDE.
-
- The default is that FDEs are not given nonlocal labels.
-
-[TARGET_ASM_EMIT_UNWIND_LABEL]
-
-[TARGET_ASM_EMIT_EXCEPT_TABLE_LABEL]
-.. function:: void TARGET_ASM_EMIT_EXCEPT_TABLE_LABEL (FILE *stream)
-
- This target hook emits a label at the beginning of the exception table.
- It should be defined on targets where it is desirable for the table
- to be broken up according to function.
-
- The default is that no label is emitted.
-
-[TARGET_ASM_EMIT_EXCEPT_TABLE_LABEL]
-
-[TARGET_ASM_EMIT_EXCEPT_PERSONALITY]
-.. function:: void TARGET_ASM_EMIT_EXCEPT_PERSONALITY (rtx personality)
-
- If the target implements ``TARGET_ASM_UNWIND_EMIT``, this hook may be
- used to emit a directive to install a personality hook into the unwind
- info. This hook should not be used if dwarf2 unwind info is used.
-
-[TARGET_ASM_EMIT_EXCEPT_PERSONALITY]
-
-[TARGET_ASM_MAKE_EH_SYMBOL_INDIRECT]
-.. function:: rtx TARGET_ASM_MAKE_EH_SYMBOL_INDIRECT (rtx origsymbol, bool pubvis)
-
- If necessary, modify personality and LSDA references to handle indirection.
- The original symbol is in ``origsymbol`` and if ``pubvis`` is true
- the symbol is visible outside the TU.
-
-[TARGET_ASM_MAKE_EH_SYMBOL_INDIRECT]
-
-[TARGET_ASM_UNWIND_EMIT]
-.. function:: void TARGET_ASM_UNWIND_EMIT (FILE *stream, rtx_insn *insn)
-
- This target hook emits assembly directives required to unwind the
- given instruction. This is only used when ``TARGET_EXCEPT_UNWIND_INFO``
- returns ``UI_TARGET``.
-
-[TARGET_ASM_UNWIND_EMIT]
-
-[TARGET_ASM_UNWIND_EMIT_BEFORE_INSN]
-.. c:var:: bool TARGET_ASM_UNWIND_EMIT_BEFORE_INSN
-
- True if the ``TARGET_ASM_UNWIND_EMIT`` hook should be called before
- the assembly for :samp:`{insn}` has been emitted, false if the hook should
- be called afterward.
-
-[TARGET_ASM_UNWIND_EMIT_BEFORE_INSN]
-
-[TARGET_ASM_SHOULD_RESTORE_CFA_STATE]
-.. function:: bool TARGET_ASM_SHOULD_RESTORE_CFA_STATE (void)
-
- For DWARF-based unwind frames, two CFI instructions provide for save and
- restore of register state. GCC maintains the current frame address (CFA)
- separately from the register bank but the unwinder in libgcc preserves this
- state along with the registers (and this is expected by the code that writes
- the unwind frames). This hook allows the target to specify that the CFA data
- is not saved/restored along with the registers by the target unwinder so that
- suitable additional instructions should be emitted to restore it.
-
-[TARGET_ASM_SHOULD_RESTORE_CFA_STATE]
-
-[TARGET_ASM_INTERNAL_LABEL]
-.. function:: void TARGET_ASM_INTERNAL_LABEL (FILE *stream, const char *prefix, unsigned long labelno)
-
- A function to output to the stdio stream :samp:`{stream}` a label whose
- name is made from the string :samp:`{prefix}` and the number :samp:`{labelno}`.
-
- It is absolutely essential that these labels be distinct from the labels
- used for user-level functions and variables. Otherwise, certain programs
- will have name conflicts with internal labels.
-
- It is desirable to exclude internal labels from the symbol table of the
- object file. Most assemblers have a naming convention for labels that
- should be excluded; on many systems, the letter :samp:`L` at the
- beginning of a label has this effect. You should find out what
- convention your system uses, and follow it.
-
- The default version of this function utilizes ``ASM_GENERATE_INTERNAL_LABEL``.
-
-[TARGET_ASM_INTERNAL_LABEL]
-
-[TARGET_ASM_DECLARE_CONSTANT_NAME]
-.. function:: void TARGET_ASM_DECLARE_CONSTANT_NAME (FILE *file, const char *name, const_tree expr, HOST_WIDE_INT size)
-
- A target hook to output to the stdio stream :samp:`{file}` any text necessary
- for declaring the name :samp:`{name}` of a constant which is being defined. This
- target hook is responsible for outputting the label definition (perhaps using
- ``assemble_label``). The argument :samp:`{exp}` is the value of the constant,
- and :samp:`{size}` is the size of the constant in bytes. The :samp:`{name}`
- will be an internal label.
-
- The default version of this target hook, define the :samp:`{name}` in the
- usual manner as a label (by means of ``assemble_label``).
-
- You may wish to use ``ASM_OUTPUT_TYPE_DIRECTIVE`` in this target hook.
-
-[TARGET_ASM_DECLARE_CONSTANT_NAME]
-
-[TARGET_ASM_TTYPE]
-.. function:: bool TARGET_ASM_TTYPE (rtx sym)
-
- This hook is used to output a reference from a frame unwinding table to
- the type_info object identified by :samp:`{sym}`. It should return ``true``
- if the reference was output. Returning ``false`` will cause the
- reference to be output using the normal Dwarf2 routines.
-
-[TARGET_ASM_TTYPE]
-
-[TARGET_ASM_ASSEMBLE_VISIBILITY]
-.. function:: void TARGET_ASM_ASSEMBLE_VISIBILITY (tree decl, int visibility)
-
- This target hook is a function to output to :samp:`{asm_out_file}` some
- commands that will make the symbol(s) associated with :samp:`{decl}` have
- hidden, protected or internal visibility as specified by :samp:`{visibility}`.
-
-[TARGET_ASM_ASSEMBLE_VISIBILITY]
-
-[TARGET_ASM_PRINT_PATCHABLE_FUNCTION_ENTRY]
-.. function:: void TARGET_ASM_PRINT_PATCHABLE_FUNCTION_ENTRY (FILE *file, unsigned HOST_WIDE_INT patch_area_size, bool record_p)
-
- Generate a patchable area at the function start, consisting of
- :samp:`{patch_area_size}` NOP instructions. If the target supports named
- sections and if :samp:`{record_p}` is true, insert a pointer to the current
- location in the table of patchable functions. The default implementation
- of the hook places the table of pointers in the special section named
- ``__patchable_function_entries``.
-
-[TARGET_ASM_PRINT_PATCHABLE_FUNCTION_ENTRY]
-
-[TARGET_ASM_FUNCTION_PROLOGUE]
-.. function:: void TARGET_ASM_FUNCTION_PROLOGUE (FILE *file)
-
- If defined, a function that outputs the assembler code for entry to a
- function. The prologue is responsible for setting up the stack frame,
- initializing the frame pointer register, saving registers that must be
- saved, and allocating :samp:`{size}` additional bytes of storage for the
- local variables. :samp:`{file}` is a stdio stream to which the assembler
- code should be output.
-
- The label for the beginning of the function need not be output by this
- macro. That has already been done when the macro is run.
-
- .. index:: regs_ever_live
-
- To determine which registers to save, the macro can refer to the array
- ``regs_ever_live`` : element :samp:`{r}` is nonzero if hard register
- :samp:`{r}` is used anywhere within the function. This implies the function
- prologue should save register :samp:`{r}`, provided it is not one of the
- call-used registers. (``TARGET_ASM_FUNCTION_EPILOGUE`` must likewise use
- ``regs_ever_live``.)
-
- On machines that have 'register windows', the function entry code does
- not save on the stack the registers that are in the windows, even if
- they are supposed to be preserved by function calls; instead it takes
- appropriate steps to 'push' the register stack, if any non-call-used
- registers are used in the function.
-
- .. index:: frame_pointer_needed
-
- On machines where functions may or may not have frame-pointers, the
- function entry code must vary accordingly; it must set up the frame
- pointer if one is wanted, and not otherwise. To determine whether a
- frame pointer is in wanted, the macro can refer to the variable
- ``frame_pointer_needed``. The variable's value will be 1 at run
- time in a function that needs a frame pointer. See :ref:`elimination`.
-
- The function entry code is responsible for allocating any stack space
- required for the function. This stack space consists of the regions
- listed below. In most cases, these regions are allocated in the
- order listed, with the last listed region closest to the top of the
- stack (the lowest address if ``STACK_GROWS_DOWNWARD`` is defined, and
- the highest address if it is not defined). You can use a different order
- for a machine if doing so is more convenient or required for
- compatibility reasons. Except in cases where required by standard
- or by a debugger, there is no reason why the stack layout used by GCC
- need agree with that used by other compilers for a machine.
-
-[TARGET_ASM_FUNCTION_PROLOGUE]
-
-[TARGET_ASM_FUNCTION_END_PROLOGUE]
-.. function:: void TARGET_ASM_FUNCTION_END_PROLOGUE (FILE *file)
-
- If defined, a function that outputs assembler code at the end of a
- prologue. This should be used when the function prologue is being
- emitted as RTL, and you have some extra assembler that needs to be
- emitted. See :ref:`prologue-instruction-pattern`.
-
-[TARGET_ASM_FUNCTION_END_PROLOGUE]
-
-[TARGET_ASM_FUNCTION_BEGIN_EPILOGUE]
-.. function:: void TARGET_ASM_FUNCTION_BEGIN_EPILOGUE (FILE *file)
-
- If defined, a function that outputs assembler code at the start of an
- epilogue. This should be used when the function epilogue is being
- emitted as RTL, and you have some extra assembler that needs to be
- emitted. See :ref:`epilogue-instruction-pattern`.
-
-[TARGET_ASM_FUNCTION_BEGIN_EPILOGUE]
-
-[TARGET_ASM_FUNCTION_EPILOGUE]
-.. function:: void TARGET_ASM_FUNCTION_EPILOGUE (FILE *file)
-
- If defined, a function that outputs the assembler code for exit from a
- function. The epilogue is responsible for restoring the saved
- registers and stack pointer to their values when the function was
- called, and returning control to the caller. This macro takes the
- same argument as the macro ``TARGET_ASM_FUNCTION_PROLOGUE``, and the
- registers to restore are determined from ``regs_ever_live`` and
- ``CALL_USED_REGISTERS`` in the same way.
-
- On some machines, there is a single instruction that does all the work
- of returning from the function. On these machines, give that
- instruction the name :samp:`return` and do not define the macro
- ``TARGET_ASM_FUNCTION_EPILOGUE`` at all.
-
- Do not define a pattern named :samp:`return` if you want the
- ``TARGET_ASM_FUNCTION_EPILOGUE`` to be used. If you want the target
- switches to control whether return instructions or epilogues are used,
- define a :samp:`return` pattern with a validity condition that tests the
- target switches appropriately. If the :samp:`return` pattern's validity
- condition is false, epilogues will be used.
-
- On machines where functions may or may not have frame-pointers, the
- function exit code must vary accordingly. Sometimes the code for these
- two cases is completely different. To determine whether a frame pointer
- is wanted, the macro can refer to the variable
- ``frame_pointer_needed``. The variable's value will be 1 when compiling
- a function that needs a frame pointer.
-
- Normally, ``TARGET_ASM_FUNCTION_PROLOGUE`` and
- ``TARGET_ASM_FUNCTION_EPILOGUE`` must treat leaf functions specially.
- The C variable ``current_function_is_leaf`` is nonzero for such a
- function. See :ref:`leaf-functions`.
-
- On some machines, some functions pop their arguments on exit while
- others leave that for the caller to do. For example, the 68020 when
- given :option:`-mrtd` pops arguments in functions that take a fixed
- number of arguments.
-
- .. index:: pops_args, crtl->args.pops_args
-
- Your definition of the macro ``RETURN_POPS_ARGS`` decides which
- functions pop their own arguments. ``TARGET_ASM_FUNCTION_EPILOGUE``
- needs to know what was decided. The number of bytes of the current
- function's arguments that this function should pop is available in
- ``crtl->args.pops_args``. See :ref:`scalar-return`.
-
-[TARGET_ASM_FUNCTION_EPILOGUE]
-
-[TARGET_ASM_INIT_SECTIONS]
-.. function:: void TARGET_ASM_INIT_SECTIONS (void)
-
- Define this hook if you need to do something special to set up the
- :samp:`varasm.cc` sections, or if your target has some special sections
- of its own that you need to create.
-
- GCC calls this hook after processing the command line, but before writing
- any assembly code, and before calling any of the section-returning hooks
- described below.
-
-[TARGET_ASM_INIT_SECTIONS]
-
-[TARGET_ASM_NAMED_SECTION]
-.. function:: void TARGET_ASM_NAMED_SECTION (const char *name, unsigned int flags, tree decl)
-
- Output assembly directives to switch to section :samp:`{name}`. The section
- should have attributes as specified by :samp:`{flags}`, which is a bit mask
- of the ``SECTION_*`` flags defined in :samp:`output.h`. If :samp:`{decl}`
- is non-NULL, it is the ``VAR_DECL`` or ``FUNCTION_DECL`` with which
- this section is associated.
-
-[TARGET_ASM_NAMED_SECTION]
-
-[TARGET_ASM_ELF_FLAGS_NUMERIC]
-.. function:: bool TARGET_ASM_ELF_FLAGS_NUMERIC (unsigned int flags, unsigned int *num)
-
- This hook can be used to encode ELF section flags for which no letter
- code has been defined in the assembler. It is called by
- ``default_asm_named_section`` whenever the section flags need to be
- emitted in the assembler output. If the hook returns true, then the
- numerical value for ELF section flags should be calculated from
- :samp:`{flags}` and saved in :samp:`{*num}` ; the value is printed out instead of the
- normal sequence of letter codes. If the hook is not defined, or if it
- returns false, then :samp:`{num}` is ignored and the traditional letter sequence
- is emitted.
-
-[TARGET_ASM_ELF_FLAGS_NUMERIC]
-
-[TARGET_ASM_FUNCTION_SECTION]
-.. function:: section * TARGET_ASM_FUNCTION_SECTION (tree decl, enum node_frequency freq, bool startup, bool exit)
-
- Return preferred text (sub)section for function :samp:`{decl}`.
- Main purpose of this function is to separate cold, normal and hot
- functions. :samp:`{startup}` is true when function is known to be used only
- at startup (from static constructors or it is ``main()``).
- :samp:`{exit}` is true when function is known to be used only at exit
- (from static destructors).
- Return NULL if function should go to default text section.
-
-[TARGET_ASM_FUNCTION_SECTION]
-
-[TARGET_ASM_FUNCTION_SWITCHED_TEXT_SECTIONS]
-.. function:: void TARGET_ASM_FUNCTION_SWITCHED_TEXT_SECTIONS (FILE *file, tree decl, bool new_is_cold)
-
- Used by the target to emit any assembler directives or additional
- labels needed when a function is partitioned between different
- sections. Output should be written to :samp:`{file}`. The function
- decl is available as :samp:`{decl}` and the new section is 'cold' if
- :samp:`{new_is_cold}` is ``true``.
-
-[TARGET_ASM_FUNCTION_SWITCHED_TEXT_SECTIONS]
-
-[TARGET_ASM_RELOC_RW_MASK]
-.. function:: int TARGET_ASM_RELOC_RW_MASK (void)
-
- Return a mask describing how relocations should be treated when
- selecting sections. Bit 1 should be set if global relocations
- should be placed in a read-write section; bit 0 should be set if
- local relocations should be placed in a read-write section.
-
- The default version of this function returns 3 when :option:`-fpic`
- is in effect, and 0 otherwise. The hook is typically redefined
- when the target cannot support (some kinds of) dynamic relocations
- in read-only sections even in executables.
-
-[TARGET_ASM_RELOC_RW_MASK]
-
-[TARGET_ASM_GENERATE_PIC_ADDR_DIFF_VEC]
-.. function:: bool TARGET_ASM_GENERATE_PIC_ADDR_DIFF_VEC (void)
-
- Return true to generate ADDR_DIF_VEC table
- or false to generate ADDR_VEC table for jumps in case of -fPIC.
-
- The default version of this function returns true if flag_pic
- equals true and false otherwise
-
-[TARGET_ASM_GENERATE_PIC_ADDR_DIFF_VEC]
-
-[TARGET_ASM_SELECT_SECTION]
-.. function:: section * TARGET_ASM_SELECT_SECTION (tree exp, int reloc, unsigned HOST_WIDE_INT align)
-
- Return the section into which :samp:`{exp}` should be placed. You can
- assume that :samp:`{exp}` is either a ``VAR_DECL`` node or a constant of
- some sort. :samp:`{reloc}` indicates whether the initial value of :samp:`{exp}`
- requires link-time relocations. Bit 0 is set when variable contains
- local relocations only, while bit 1 is set for global relocations.
- :samp:`{align}` is the constant alignment in bits.
-
- The default version of this function takes care of putting read-only
- variables in ``readonly_data_section``.
-
- See also :samp:`{USE_SELECT_SECTION_FOR_FUNCTIONS}`.
-
-[TARGET_ASM_SELECT_SECTION]
-
-[TARGET_ASM_SELECT_RTX_SECTION]
-.. function:: section * TARGET_ASM_SELECT_RTX_SECTION (machine_mode mode, rtx x, unsigned HOST_WIDE_INT align)
-
- Return the section into which a constant :samp:`{x}`, of mode :samp:`{mode}`,
- should be placed. You can assume that :samp:`{x}` is some kind of
- constant in RTL. The argument :samp:`{mode}` is redundant except in the
- case of a ``const_int`` rtx. :samp:`{align}` is the constant alignment
- in bits.
-
- The default version of this function takes care of putting symbolic
- constants in ``flag_pic`` mode in ``data_section`` and everything
- else in ``readonly_data_section``.
-
-[TARGET_ASM_SELECT_RTX_SECTION]
-
-[TARGET_ASM_UNIQUE_SECTION]
-.. function:: void TARGET_ASM_UNIQUE_SECTION (tree decl, int reloc)
-
- Build up a unique section name, expressed as a ``STRING_CST`` node,
- and assign it to :samp:`DECL_SECTION_NAME ({decl})`.
- As with ``TARGET_ASM_SELECT_SECTION``, :samp:`{reloc}` indicates whether
- the initial value of :samp:`{exp}` requires link-time relocations.
-
- The default version of this function appends the symbol name to the
- ELF section name that would normally be used for the symbol. For
- example, the function ``foo`` would be placed in ``.text.foo``.
- Whatever the actual target object format, this is often good enough.
-
-[TARGET_ASM_UNIQUE_SECTION]
-
-[TARGET_ASM_FUNCTION_RODATA_SECTION]
-.. function:: section * TARGET_ASM_FUNCTION_RODATA_SECTION (tree decl, bool relocatable)
-
- Return the readonly data or reloc readonly data section associated with
- :samp:`DECL_SECTION_NAME ({decl})`. :samp:`{relocatable}` selects the latter
- over the former.
- The default version of this function selects ``.gnu.linkonce.r.name`` if
- the function's section is ``.gnu.linkonce.t.name``, ``.rodata.name``
- or ``.data.rel.ro.name`` if function is in ``.text.name``, and
- the normal readonly-data or reloc readonly data section otherwise.
-
-[TARGET_ASM_FUNCTION_RODATA_SECTION]
-
-[TARGET_ASM_MERGEABLE_RODATA_PREFIX]
-.. c:var:: const char * TARGET_ASM_MERGEABLE_RODATA_PREFIX
-
- Usually, the compiler uses the prefix ``".rodata"`` to construct
- section names for mergeable constant data. Define this macro to override
- the string if a different section name should be used.
-
-[TARGET_ASM_MERGEABLE_RODATA_PREFIX]
-
-[TARGET_ASM_TM_CLONE_TABLE_SECTION]
-.. function:: section * TARGET_ASM_TM_CLONE_TABLE_SECTION (void)
-
- Return the section that should be used for transactional memory clone
- tables.
-
-[TARGET_ASM_TM_CLONE_TABLE_SECTION]
-
-[TARGET_ASM_CONSTRUCTOR]
-.. function:: void TARGET_ASM_CONSTRUCTOR (rtx symbol, int priority)
-
- If defined, a function that outputs assembler code to arrange to call
- the function referenced by :samp:`{symbol}` at initialization time.
-
- Assume that :samp:`{symbol}` is a ``SYMBOL_REF`` for a function taking
- no arguments and with no return value. If the target supports initialization
- priorities, :samp:`{priority}` is a value between 0 and ``MAX_INIT_PRIORITY`` ;
- otherwise it must be ``DEFAULT_INIT_PRIORITY``.
-
- If this macro is not defined by the target, a suitable default will
- be chosen if (1) the target supports arbitrary section names, (2) the
- target defines ``CTORS_SECTION_ASM_OP``, or (3) ``USE_COLLECT2``
- is not defined.
-
-[TARGET_ASM_CONSTRUCTOR]
-
-[TARGET_ASM_DESTRUCTOR]
-.. function:: void TARGET_ASM_DESTRUCTOR (rtx symbol, int priority)
-
- This is like ``TARGET_ASM_CONSTRUCTOR`` but used for termination
- functions rather than initialization functions.
-
-[TARGET_ASM_DESTRUCTOR]
-
-[TARGET_ASM_OUTPUT_MI_THUNK]
-.. function:: void TARGET_ASM_OUTPUT_MI_THUNK (FILE *file, tree thunk_fndecl, HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset, tree function)
-
- A function that outputs the assembler code for a thunk
- function, used to implement C++ virtual function calls with multiple
- inheritance. The thunk acts as a wrapper around a virtual function,
- adjusting the implicit object parameter before handing control off to
- the real function.
-
- First, emit code to add the integer :samp:`{delta}` to the location that
- contains the incoming first argument. Assume that this argument
- contains a pointer, and is the one used to pass the ``this`` pointer
- in C++. This is the incoming argument *before* the function prologue,
- e.g. :samp:`%o0` on a sparc. The addition must preserve the values of
- all other incoming arguments.
-
- Then, if :samp:`{vcall_offset}` is nonzero, an additional adjustment should be
- made after adding ``delta``. In particular, if :samp:`{p}` is the
- adjusted pointer, the following adjustment should be made:
-
- .. code-block:: c++
-
- p += (*((ptrdiff_t **)p))[vcall_offset/sizeof(ptrdiff_t)]
-
- After the additions, emit code to jump to :samp:`{function}`, which is a
- ``FUNCTION_DECL``. This is a direct pure jump, not a call, and does
- not touch the return address. Hence returning from :samp:`{FUNCTION}` will
- return to whoever called the current :samp:`thunk`.
-
- The effect must be as if :samp:`{function}` had been called directly with
- the adjusted first argument. This macro is responsible for emitting all
- of the code for a thunk function; ``TARGET_ASM_FUNCTION_PROLOGUE``
- and ``TARGET_ASM_FUNCTION_EPILOGUE`` are not invoked.
-
- The :samp:`{thunk_fndecl}` is redundant. (:samp:`{delta}` and :samp:`{function}`
- have already been extracted from it.) It might possibly be useful on
- some targets, but probably not.
-
- If you do not define this macro, the target-independent code in the C++
- front end will generate a less efficient heavyweight thunk that calls
- :samp:`{function}` instead of jumping to it. The generic approach does
- not support varargs.
-
-[TARGET_ASM_OUTPUT_MI_THUNK]
-
-[TARGET_ASM_CAN_OUTPUT_MI_THUNK]
-.. function:: bool TARGET_ASM_CAN_OUTPUT_MI_THUNK (const_tree thunk_fndecl, HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset, const_tree function)
-
- A function that returns true if TARGET_ASM_OUTPUT_MI_THUNK would be able
- to output the assembler code for the thunk function specified by the
- arguments it is passed, and false otherwise. In the latter case, the
- generic approach will be used by the C++ front end, with the limitations
- previously exposed.
-
-[TARGET_ASM_CAN_OUTPUT_MI_THUNK]
-
-[TARGET_ASM_FILE_START]
-.. function:: void TARGET_ASM_FILE_START (void)
-
- Output to ``asm_out_file`` any text which the assembler expects to
- find at the beginning of a file. The default behavior is controlled
- by two flags, documented below. Unless your target's assembler is
- quite unusual, if you override the default, you should call
- ``default_file_start`` at some point in your target hook. This
- lets other target files rely on these variables.
-
-[TARGET_ASM_FILE_START]
-
-[TARGET_ASM_FILE_END]
-.. function:: void TARGET_ASM_FILE_END (void)
-
- Output to ``asm_out_file`` any text which the assembler expects
- to find at the end of a file. The default is to output nothing.
-
-[TARGET_ASM_FILE_END]
-
-[TARGET_ASM_LTO_START]
-.. function:: void TARGET_ASM_LTO_START (void)
-
- Output to ``asm_out_file`` any text which the assembler expects
- to find at the start of an LTO section. The default is to output
- nothing.
-
-[TARGET_ASM_LTO_START]
-
-[TARGET_ASM_LTO_END]
-.. function:: void TARGET_ASM_LTO_END (void)
-
- Output to ``asm_out_file`` any text which the assembler expects
- to find at the end of an LTO section. The default is to output
- nothing.
-
-[TARGET_ASM_LTO_END]
-
-[TARGET_ASM_CODE_END]
-.. function:: void TARGET_ASM_CODE_END (void)
-
- Output to ``asm_out_file`` any text which is needed before emitting
- unwind info and debug info at the end of a file. Some targets emit
- here PIC setup thunks that cannot be emitted at the end of file,
- because they couldn't have unwind info then. The default is to output
- nothing.
-
-[TARGET_ASM_CODE_END]
-
-[TARGET_ASM_EXTERNAL_LIBCALL]
-.. function:: void TARGET_ASM_EXTERNAL_LIBCALL (rtx symref)
-
- This target hook is a function to output to :samp:`{asm_out_file}` an assembler
- pseudo-op to declare a library function name external. The name of the
- library function is given by :samp:`{symref}`, which is a ``symbol_ref``.
-
-[TARGET_ASM_EXTERNAL_LIBCALL]
-
-[TARGET_ASM_MARK_DECL_PRESERVED]
-.. function:: void TARGET_ASM_MARK_DECL_PRESERVED (const char *symbol)
-
- This target hook is a function to output to :samp:`{asm_out_file}` an assembler
- directive to annotate :samp:`{symbol}` as used. The Darwin target uses the
- .no_dead_code_strip directive.
-
-[TARGET_ASM_MARK_DECL_PRESERVED]
-
-[TARGET_ASM_RECORD_GCC_SWITCHES]
-.. function:: void TARGET_ASM_RECORD_GCC_SWITCHES (const char *)
-
- Provides the target with the ability to record the gcc command line
- switches provided as argument.
-
- By default this hook is set to NULL, but an example implementation is
- provided for ELF based targets. Called :samp:`{elf_record_gcc_switches}`,
- it records the switches as ASCII text inside a new, string mergeable
- section in the assembler output file. The name of the new section is
- provided by the ``TARGET_ASM_RECORD_GCC_SWITCHES_SECTION`` target
- hook.
-
-[TARGET_ASM_RECORD_GCC_SWITCHES]
-
-[TARGET_ASM_RECORD_GCC_SWITCHES_SECTION]
-.. c:var:: const char * TARGET_ASM_RECORD_GCC_SWITCHES_SECTION
-
- This is the name of the section that will be created by the example
- ELF implementation of the ``TARGET_ASM_RECORD_GCC_SWITCHES`` target
- hook.
-
-[TARGET_ASM_RECORD_GCC_SWITCHES_SECTION]
-
-[TARGET_ASM_OUTPUT_ANCHOR]
-.. function:: void TARGET_ASM_OUTPUT_ANCHOR (rtx x)
-
- Write the assembly code to define section anchor :samp:`{x}`, which is a
- ``SYMBOL_REF`` for which :samp:`SYMBOL_REF_ANCHOR_P ({x})` is true.
- The hook is called with the assembly output position set to the beginning
- of ``SYMBOL_REF_BLOCK (x)``.
-
- If ``ASM_OUTPUT_DEF`` is available, the hook's default definition uses
- it to define the symbol as :samp:`. + SYMBOL_REF_BLOCK_OFFSET ({x})`.
- If ``ASM_OUTPUT_DEF`` is not available, the hook's default definition
- is ``NULL``, which disables the use of section anchors altogether.
-
-[TARGET_ASM_OUTPUT_ANCHOR]
-
-[TARGET_ASM_OUTPUT_IDENT]
-.. function:: void TARGET_ASM_OUTPUT_IDENT (const char *name)
-
- Output a string based on :samp:`{name}`, suitable for the :samp:`#ident`
- directive, or the equivalent directive or pragma in non-C-family languages.
- If this hook is not defined, nothing is output for the :samp:`#ident`
- directive.
-
-[TARGET_ASM_OUTPUT_IDENT]
-
-[TARGET_ASM_OUTPUT_DWARF_DTPREL]
-.. function:: void TARGET_ASM_OUTPUT_DWARF_DTPREL (FILE *file, int size, rtx x)
-
- If defined, this target hook is a function which outputs a DTP-relative
- reference to the given TLS symbol of the specified size.
-
-[TARGET_ASM_OUTPUT_DWARF_DTPREL]
-
-[TARGET_ASM_FINAL_POSTSCAN_INSN]
-.. function:: void TARGET_ASM_FINAL_POSTSCAN_INSN (FILE *file, rtx_insn *insn, rtx *opvec, int noperands)
-
- If defined, this target hook is a function which is executed just after the
- output of assembler code for :samp:`{insn}`, to change the mode of the assembler
- if necessary.
-
- Here the argument :samp:`{opvec}` is the vector containing the operands
- extracted from :samp:`{insn}`, and :samp:`{noperands}` is the number of
- elements of the vector which contain meaningful data for this insn.
- The contents of this vector are what was used to convert the insn
- template into assembler code, so you can change the assembler mode
- by checking the contents of the vector.
-
-[TARGET_ASM_FINAL_POSTSCAN_INSN]
-
-[TARGET_ASM_TRAMPOLINE_TEMPLATE]
-.. function:: void TARGET_ASM_TRAMPOLINE_TEMPLATE (FILE *f)
-
- This hook is called by ``assemble_trampoline_template`` to output,
- on the stream :samp:`{f}`, assembler code for a block of data that contains
- the constant parts of a trampoline. This code should not include a
- label---the label is taken care of automatically.
-
- If you do not define this hook, it means no template is needed
- for the target. Do not define this hook on systems where the block move
- code to copy the trampoline into place would be larger than the code
- to generate it on the spot.
-
-[TARGET_ASM_TRAMPOLINE_TEMPLATE]
-
-[TARGET_ASM_OUTPUT_SOURCE_FILENAME]
-.. function:: void TARGET_ASM_OUTPUT_SOURCE_FILENAME (FILE *file, const char *name)
-
- Output DWARF debugging information which indicates that filename
- :samp:`{name}` is the current source file to the stdio stream :samp:`{file}`.
-
- This target hook need not be defined if the standard form of output
- for the file format in use is appropriate.
-
-[TARGET_ASM_OUTPUT_SOURCE_FILENAME]
-
-[TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA]
-.. function:: bool TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA (FILE *file, rtx x)
-
- A target hook to recognize :samp:`{rtx}` patterns that ``output_addr_const``
- can't deal with, and output assembly code to :samp:`{file}` corresponding to
- the pattern :samp:`{x}`. This may be used to allow machine-dependent
- ``UNSPEC`` s to appear within constants.
-
- If target hook fails to recognize a pattern, it must return ``false``,
- so that a standard error message is printed. If it prints an error message
- itself, by calling, for example, ``output_operand_lossage``, it may just
- return ``true``.
-
-[TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA]
-
-[TARGET_MANGLE_ASSEMBLER_NAME]
-.. function:: tree TARGET_MANGLE_ASSEMBLER_NAME (const char *name)
-
- Given a symbol :samp:`{name}`, perform same mangling as ``varasm.cc`` 's
- ``assemble_name``, but in memory rather than to a file stream, returning
- result as an ``IDENTIFIER_NODE``. Required for correct LTO symtabs. The
- default implementation calls the ``TARGET_STRIP_NAME_ENCODING`` hook and
- then prepends the ``USER_LABEL_PREFIX``, if any.
-
-[TARGET_MANGLE_ASSEMBLER_NAME]
-
-[TARGET_SCHED_ADJUST_COST]
-.. function:: int TARGET_SCHED_ADJUST_COST (rtx_insn *insn, int dep_type1, rtx_insn *dep_insn, int cost, unsigned int dw)
-
- This function corrects the value of :samp:`{cost}` based on the
- relationship between :samp:`{insn}` and :samp:`{dep_insn}` through a
- dependence of type dep_type, and strength :samp:`{dw}`. It should return the new
- value. The default is to make no adjustment to :samp:`{cost}`. This can be
- used for example to specify to the scheduler using the traditional pipeline
- description that an output- or anti-dependence does not incur the same cost
- as a data-dependence. If the scheduler using the automaton based pipeline
- description, the cost of anti-dependence is zero and the cost of
- output-dependence is maximum of one and the difference of latency
- times of the first and the second insns. If these values are not
- acceptable, you could use the hook to modify them too. See also
- see :ref:`processor-pipeline-description`.
-
-[TARGET_SCHED_ADJUST_COST]
-
-[TARGET_SCHED_ADJUST_PRIORITY]
-.. function:: int TARGET_SCHED_ADJUST_PRIORITY (rtx_insn *insn, int priority)
-
- This hook adjusts the integer scheduling priority :samp:`{priority}` of
- :samp:`{insn}`. It should return the new priority. Increase the priority to
- execute :samp:`{insn}` earlier, reduce the priority to execute :samp:`{insn}`
- later. Do not define this hook if you do not need to adjust the
- scheduling priorities of insns.
-
-[TARGET_SCHED_ADJUST_PRIORITY]
-
-[TARGET_SCHED_ISSUE_RATE]
-.. function:: int TARGET_SCHED_ISSUE_RATE (void)
-
- This hook returns the maximum number of instructions that can ever
- issue at the same time on the target machine. The default is one.
- Although the insn scheduler can define itself the possibility of issue
- an insn on the same cycle, the value can serve as an additional
- constraint to issue insns on the same simulated processor cycle (see
- hooks :samp:`TARGET_SCHED_REORDER` and :samp:`TARGET_SCHED_REORDER2`).
- This value must be constant over the entire compilation. If you need
- it to vary depending on what the instructions are, you must use
- :samp:`TARGET_SCHED_VARIABLE_ISSUE`.
-
-[TARGET_SCHED_ISSUE_RATE]
-
-[TARGET_SCHED_VARIABLE_ISSUE]
-.. function:: int TARGET_SCHED_VARIABLE_ISSUE (FILE *file, int verbose, rtx_insn *insn, int more)
-
- This hook is executed by the scheduler after it has scheduled an insn
- from the ready list. It should return the number of insns which can
- still be issued in the current cycle. The default is
- :samp:`{more} - 1` for insns other than ``CLOBBER`` and
- ``USE``, which normally are not counted against the issue rate.
- You should define this hook if some insns take more machine resources
- than others, so that fewer insns can follow them in the same cycle.
- :samp:`{file}` is either a null pointer, or a stdio stream to write any
- debug output to. :samp:`{verbose}` is the verbose level provided by
- :option:`-fsched-verbose-n`. :samp:`{insn}` is the instruction that
- was scheduled.
-
-[TARGET_SCHED_VARIABLE_ISSUE]
-
-[TARGET_SCHED_INIT]
-.. function:: void TARGET_SCHED_INIT (FILE *file, int verbose, int max_ready)
-
- This hook is executed by the scheduler at the beginning of each block of
- instructions that are to be scheduled. :samp:`{file}` is either a null
- pointer, or a stdio stream to write any debug output to. :samp:`{verbose}`
- is the verbose level provided by :option:`-fsched-verbose-n`.
- :samp:`{max_ready}` is the maximum number of insns in the current scheduling
- region that can be live at the same time. This can be used to allocate
- scratch space if it is needed, e.g. by :samp:`TARGET_SCHED_REORDER`.
-
-[TARGET_SCHED_INIT]
-
-[TARGET_SCHED_FINISH]
-.. function:: void TARGET_SCHED_FINISH (FILE *file, int verbose)
-
- This hook is executed by the scheduler at the end of each block of
- instructions that are to be scheduled. It can be used to perform
- cleanup of any actions done by the other scheduling hooks. :samp:`{file}`
- is either a null pointer, or a stdio stream to write any debug output
- to. :samp:`{verbose}` is the verbose level provided by
- :option:`-fsched-verbose-n`.
-
-[TARGET_SCHED_FINISH]
-
-[TARGET_SCHED_INIT_GLOBAL]
-.. function:: void TARGET_SCHED_INIT_GLOBAL (FILE *file, int verbose, int old_max_uid)
-
- This hook is executed by the scheduler after function level initializations.
- :samp:`{file}` is either a null pointer, or a stdio stream to write any debug output to.
- :samp:`{verbose}` is the verbose level provided by :option:`-fsched-verbose-n`.
- :samp:`{old_max_uid}` is the maximum insn uid when scheduling begins.
-
-[TARGET_SCHED_INIT_GLOBAL]
-
-[TARGET_SCHED_FINISH_GLOBAL]
-.. function:: void TARGET_SCHED_FINISH_GLOBAL (FILE *file, int verbose)
-
- This is the cleanup hook corresponding to ``TARGET_SCHED_INIT_GLOBAL``.
- :samp:`{file}` is either a null pointer, or a stdio stream to write any debug output to.
- :samp:`{verbose}` is the verbose level provided by :option:`-fsched-verbose-n`.
-
-[TARGET_SCHED_FINISH_GLOBAL]
-
-[TARGET_SCHED_REORDER]
-.. function:: int TARGET_SCHED_REORDER (FILE *file, int verbose, rtx_insn **ready, int *n_readyp, int clock)
-
- This hook is executed by the scheduler after it has scheduled the ready
- list, to allow the machine description to reorder it (for example to
- combine two small instructions together on :samp:`VLIW` machines).
- :samp:`{file}` is either a null pointer, or a stdio stream to write any
- debug output to. :samp:`{verbose}` is the verbose level provided by
- :option:`-fsched-verbose-n`. :samp:`{ready}` is a pointer to the ready
- list of instructions that are ready to be scheduled. :samp:`{n_readyp}` is
- a pointer to the number of elements in the ready list. The scheduler
- reads the ready list in reverse order, starting with
- :samp:`{ready}` [ :samp:`{*n_readyp}` - 1] and going to :samp:`{ready}` [0]. :samp:`{clock}`
- is the timer tick of the scheduler. You may modify the ready list and
- the number of ready insns. The return value is the number of insns that
- can issue this cycle; normally this is just ``issue_rate``. See also
- :samp:`TARGET_SCHED_REORDER2`.
-
-[TARGET_SCHED_REORDER]
-
-[TARGET_SCHED_REORDER2]
-.. function:: int TARGET_SCHED_REORDER2 (FILE *file, int verbose, rtx_insn **ready, int *n_readyp, int clock)
-
- Like :samp:`TARGET_SCHED_REORDER`, but called at a different time. That
- function is called whenever the scheduler starts a new cycle. This one
- is called once per iteration over a cycle, immediately after
- :samp:`TARGET_SCHED_VARIABLE_ISSUE`; it can reorder the ready list and
- return the number of insns to be scheduled in the same cycle. Defining
- this hook can be useful if there are frequent situations where
- scheduling one insn causes other insns to become ready in the same
- cycle. These other insns can then be taken into account properly.
-
-[TARGET_SCHED_REORDER2]
-
-[TARGET_SCHED_MACRO_FUSION_P]
-.. function:: bool TARGET_SCHED_MACRO_FUSION_P (void)
-
- This hook is used to check whether target platform supports macro fusion.
-
-[TARGET_SCHED_MACRO_FUSION_P]
-
-[TARGET_SCHED_MACRO_FUSION_PAIR_P]
-.. function:: bool TARGET_SCHED_MACRO_FUSION_PAIR_P (rtx_insn *prev, rtx_insn *curr)
-
- This hook is used to check whether two insns should be macro fused for
- a target microarchitecture. If this hook returns true for the given insn pair
- (:samp:`{prev}` and :samp:`{curr}`), the scheduler will put them into a sched
- group, and they will not be scheduled apart. The two insns will be either
- two SET insns or a compare and a conditional jump and this hook should
- validate any dependencies needed to fuse the two insns together.
-
-[TARGET_SCHED_MACRO_FUSION_PAIR_P]
-
-[TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK]
-.. function:: void TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK (rtx_insn *head, rtx_insn *tail)
-
- This hook is called after evaluation forward dependencies of insns in
- chain given by two parameter values (:samp:`{head}` and :samp:`{tail}`
- correspondingly) but before insns scheduling of the insn chain. For
- example, it can be used for better insn classification if it requires
- analysis of dependencies. This hook can use backward and forward
- dependencies of the insn scheduler because they are already
- calculated.
-
-[TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK]
-
-[TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN]
-.. function:: void TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN (void)
-
- The hook can be used to initialize data used by the previous hook.
-
-[TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN]
-
-[TARGET_SCHED_DFA_PRE_CYCLE_INSN]
-.. function:: rtx TARGET_SCHED_DFA_PRE_CYCLE_INSN (void)
-
- The hook returns an RTL insn. The automaton state used in the
- pipeline hazard recognizer is changed as if the insn were scheduled
- when the new simulated processor cycle starts. Usage of the hook may
- simplify the automaton pipeline description for some VLIW
- processors. If the hook is defined, it is used only for the automaton
- based pipeline description. The default is not to change the state
- when the new simulated processor cycle starts.
-
-[TARGET_SCHED_DFA_PRE_CYCLE_INSN]
-
-[TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN]
-.. function:: void TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN (void)
-
- The hook is analogous to :samp:`TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN` but
- used to initialize data used by the previous hook.
-
-[TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN]
-
-[TARGET_SCHED_DFA_POST_CYCLE_INSN]
-.. function:: rtx_insn * TARGET_SCHED_DFA_POST_CYCLE_INSN (void)
-
- The hook is analogous to :samp:`TARGET_SCHED_DFA_PRE_CYCLE_INSN` but used
- to changed the state as if the insn were scheduled when the new
- simulated processor cycle finishes.
-
-[TARGET_SCHED_DFA_POST_CYCLE_INSN]
-
-[TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE]
-.. function:: void TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE (void)
-
- The hook to notify target that the current simulated cycle is about to finish.
- The hook is analogous to :samp:`TARGET_SCHED_DFA_PRE_CYCLE_INSN` but used
- to change the state in more complicated situations - e.g., when advancing
- state on a single insn is not enough.
-
-[TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE]
-
-[TARGET_SCHED_DFA_POST_ADVANCE_CYCLE]
-.. function:: void TARGET_SCHED_DFA_POST_ADVANCE_CYCLE (void)
-
- The hook to notify target that new simulated cycle has just started.
- The hook is analogous to :samp:`TARGET_SCHED_DFA_POST_CYCLE_INSN` but used
- to change the state in more complicated situations - e.g., when advancing
- state on a single insn is not enough.
-
-[TARGET_SCHED_DFA_POST_ADVANCE_CYCLE]
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD]
-.. function:: int TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD (void)
-
- This hook controls better choosing an insn from the ready insn queue
- for the DFA-based insn scheduler. Usually the scheduler
- chooses the first insn from the queue. If the hook returns a positive
- value, an additional scheduler code tries all permutations of
- :samp:`TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD ()`
- subsequent ready insns to choose an insn whose issue will result in
- maximal number of issued insns on the same cycle. For the
- VLIW processor, the code could actually solve the problem of
- packing simple insns into the VLIW insn. Of course, if the
- rules of VLIW packing are described in the automaton.
-
- This code also could be used for superscalar RISC
- processors. Let us consider a superscalar RISC processor
- with 3 pipelines. Some insns can be executed in pipelines :samp:`{A}` or
- :samp:`{B}`, some insns can be executed only in pipelines :samp:`{B}` or
- :samp:`{C}`, and one insn can be executed in pipeline :samp:`{B}`. The
- processor may issue the 1st insn into :samp:`{A}` and the 2nd one into
- :samp:`{B}`. In this case, the 3rd insn will wait for freeing :samp:`{B}`
- until the next cycle. If the scheduler issues the 3rd insn the first,
- the processor could issue all 3 insns per cycle.
-
- Actually this code demonstrates advantages of the automaton based
- pipeline hazard recognizer. We try quickly and easy many insn
- schedules to choose the best one.
-
- The default is no multipass scheduling.
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD]
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD]
-.. function:: int TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD (rtx_insn *insn, int ready_index)
-
- This hook controls what insns from the ready insn queue will be
- considered for the multipass insn scheduling. If the hook returns
- zero for :samp:`{insn}`, the insn will be considered in multipass scheduling.
- Positive return values will remove :samp:`{insn}` from consideration on
- the current round of multipass scheduling.
- Negative return values will remove :samp:`{insn}` from consideration for given
- number of cycles.
- Backends should be careful about returning non-zero for highest priority
- instruction at position 0 in the ready list. :samp:`{ready_index}` is passed
- to allow backends make correct judgements.
-
- The default is that any ready insns can be chosen to be issued.
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD]
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BEGIN]
-.. function:: void TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BEGIN (void *data, signed char *ready_try, int n_ready, bool first_cycle_insn_p)
-
- This hook prepares the target backend for a new round of multipass
- scheduling.
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BEGIN]
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_ISSUE]
-.. function:: void TARGET_SCHED_FIRST_CYCLE_MULTIPASS_ISSUE (void *data, signed char *ready_try, int n_ready, rtx_insn *insn, const void *prev_data)
-
- This hook is called when multipass scheduling evaluates instruction INSN.
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_ISSUE]
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BACKTRACK]
-.. function:: void TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BACKTRACK (const void *data, signed char *ready_try, int n_ready)
-
- This is called when multipass scheduling backtracks from evaluation of
- an instruction.
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BACKTRACK]
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_END]
-.. function:: void TARGET_SCHED_FIRST_CYCLE_MULTIPASS_END (const void *data)
-
- This hook notifies the target about the result of the concluded current
- round of multipass scheduling.
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_END]
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_INIT]
-.. function:: void TARGET_SCHED_FIRST_CYCLE_MULTIPASS_INIT (void *data)
-
- This hook initializes target-specific data used in multipass scheduling.
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_INIT]
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_FINI]
-.. function:: void TARGET_SCHED_FIRST_CYCLE_MULTIPASS_FINI (void *data)
-
- This hook finalizes target-specific data used in multipass scheduling.
-
-[TARGET_SCHED_FIRST_CYCLE_MULTIPASS_FINI]
-
-[TARGET_SCHED_DFA_NEW_CYCLE]
-.. function:: int TARGET_SCHED_DFA_NEW_CYCLE (FILE *dump, int verbose, rtx_insn *insn, int last_clock, int clock, int *sort_p)
-
- This hook is called by the insn scheduler before issuing :samp:`{insn}`
- on cycle :samp:`{clock}`. If the hook returns nonzero,
- :samp:`{insn}` is not issued on this processor cycle. Instead,
- the processor cycle is advanced. If \* :samp:`{sort_p}`
- is zero, the insn ready queue is not sorted on the new cycle
- start as usually. :samp:`{dump}` and :samp:`{verbose}` specify the file and
- verbosity level to use for debugging output.
- :samp:`{last_clock}` and :samp:`{clock}` are, respectively, the
- processor cycle on which the previous insn has been issued,
- and the current processor cycle.
-
-[TARGET_SCHED_DFA_NEW_CYCLE]
-
-[TARGET_SCHED_IS_COSTLY_DEPENDENCE]
-.. function:: bool TARGET_SCHED_IS_COSTLY_DEPENDENCE (struct _dep *_dep, int cost, int distance)
-
- This hook is used to define which dependences are considered costly by
- the target, so costly that it is not advisable to schedule the insns that
- are involved in the dependence too close to one another. The parameters
- to this hook are as follows: The first parameter :samp:`{_dep}` is the dependence
- being evaluated. The second parameter :samp:`{cost}` is the cost of the
- dependence as estimated by the scheduler, and the third
- parameter :samp:`{distance}` is the distance in cycles between the two insns.
- The hook returns ``true`` if considering the distance between the two
- insns the dependence between them is considered costly by the target,
- and ``false`` otherwise.
-
- Defining this hook can be useful in multiple-issue out-of-order machines,
- where (a) it's practically hopeless to predict the actual data/resource
- delays, however: (b) there's a better chance to predict the actual grouping
- that will be formed, and (c) correctly emulating the grouping can be very
- important. In such targets one may want to allow issuing dependent insns
- closer to one another---i.e., closer than the dependence distance; however,
- not in cases of 'costly dependences', which this hooks allows to define.
-
-[TARGET_SCHED_IS_COSTLY_DEPENDENCE]
-
-[TARGET_SCHED_H_I_D_EXTENDED]
-.. function:: void TARGET_SCHED_H_I_D_EXTENDED (void)
-
- This hook is called by the insn scheduler after emitting a new instruction to
- the instruction stream. The hook notifies a target backend to extend its
- per instruction data structures.
-
-[TARGET_SCHED_H_I_D_EXTENDED]
-
-[TARGET_SCHED_ALLOC_SCHED_CONTEXT]
-.. function:: void * TARGET_SCHED_ALLOC_SCHED_CONTEXT (void)
-
- Return a pointer to a store large enough to hold target scheduling context.
-
-[TARGET_SCHED_ALLOC_SCHED_CONTEXT]
-
-[TARGET_SCHED_INIT_SCHED_CONTEXT]
-.. function:: void TARGET_SCHED_INIT_SCHED_CONTEXT (void *tc, bool clean_p)
-
- Initialize store pointed to by :samp:`{tc}` to hold target scheduling context.
- It :samp:`{clean_p}` is true then initialize :samp:`{tc}` as if scheduler is at the
- beginning of the block. Otherwise, copy the current context into :samp:`{tc}`.
-
-[TARGET_SCHED_INIT_SCHED_CONTEXT]
-
-[TARGET_SCHED_SET_SCHED_CONTEXT]
-.. function:: void TARGET_SCHED_SET_SCHED_CONTEXT (void *tc)
-
- Copy target scheduling context pointed to by :samp:`{tc}` to the current context.
-
-[TARGET_SCHED_SET_SCHED_CONTEXT]
-
-[TARGET_SCHED_CLEAR_SCHED_CONTEXT]
-.. function:: void TARGET_SCHED_CLEAR_SCHED_CONTEXT (void *tc)
-
- Deallocate internal data in target scheduling context pointed to by :samp:`{tc}`.
-
-[TARGET_SCHED_CLEAR_SCHED_CONTEXT]
-
-[TARGET_SCHED_FREE_SCHED_CONTEXT]
-.. function:: void TARGET_SCHED_FREE_SCHED_CONTEXT (void *tc)
-
- Deallocate a store for target scheduling context pointed to by :samp:`{tc}`.
-
-[TARGET_SCHED_FREE_SCHED_CONTEXT]
-
-[TARGET_SCHED_SPECULATE_INSN]
-.. function:: int TARGET_SCHED_SPECULATE_INSN (rtx_insn *insn, unsigned int dep_status, rtx *new_pat)
-
- This hook is called by the insn scheduler when :samp:`{insn}` has only
- speculative dependencies and therefore can be scheduled speculatively.
- The hook is used to check if the pattern of :samp:`{insn}` has a speculative
- version and, in case of successful check, to generate that speculative
- pattern. The hook should return 1, if the instruction has a speculative form,
- or -1, if it doesn't. :samp:`{request}` describes the type of requested
- speculation. If the return value equals 1 then :samp:`{new_pat}` is assigned
- the generated speculative pattern.
-
-[TARGET_SCHED_SPECULATE_INSN]
-
-[TARGET_SCHED_NEEDS_BLOCK_P]
-.. function:: bool TARGET_SCHED_NEEDS_BLOCK_P (unsigned int dep_status)
-
- This hook is called by the insn scheduler during generation of recovery code
- for :samp:`{insn}`. It should return ``true``, if the corresponding check
- instruction should branch to recovery code, or ``false`` otherwise.
-
-[TARGET_SCHED_NEEDS_BLOCK_P]
-
-[TARGET_SCHED_GEN_SPEC_CHECK]
-.. function:: rtx TARGET_SCHED_GEN_SPEC_CHECK (rtx_insn *insn, rtx_insn *label, unsigned int ds)
-
- This hook is called by the insn scheduler to generate a pattern for recovery
- check instruction. If :samp:`{mutate_p}` is zero, then :samp:`{insn}` is a
- speculative instruction for which the check should be generated.
- :samp:`{label}` is either a label of a basic block, where recovery code should
- be emitted, or a null pointer, when requested check doesn't branch to
- recovery code (a simple check). If :samp:`{mutate_p}` is nonzero, then
- a pattern for a branchy check corresponding to a simple check denoted by
- :samp:`{insn}` should be generated. In this case :samp:`{label}` can't be null.
-
-[TARGET_SCHED_GEN_SPEC_CHECK]
-
-[TARGET_SCHED_SET_SCHED_FLAGS]
-.. function:: void TARGET_SCHED_SET_SCHED_FLAGS (struct spec_info_def *spec_info)
-
- This hook is used by the insn scheduler to find out what features should be
- enabled/used.
- The structure \* :samp:`{spec_info}` should be filled in by the target.
- The structure describes speculation types that can be used in the scheduler.
-
-[TARGET_SCHED_SET_SCHED_FLAGS]
-
-[TARGET_SCHED_CAN_SPECULATE_INSN]
-.. function:: bool TARGET_SCHED_CAN_SPECULATE_INSN (rtx_insn *insn)
-
- Some instructions should never be speculated by the schedulers, usually
- because the instruction is too expensive to get this wrong. Often such
- instructions have long latency, and often they are not fully modeled in the
- pipeline descriptions. This hook should return ``false`` if :samp:`{insn}`
- should not be speculated.
-
-[TARGET_SCHED_CAN_SPECULATE_INSN]
-
-[TARGET_SCHED_SMS_RES_MII]
-.. function:: int TARGET_SCHED_SMS_RES_MII (struct ddg *g)
-
- This hook is called by the swing modulo scheduler to calculate a
- resource-based lower bound which is based on the resources available in
- the machine and the resources required by each instruction. The target
- backend can use :samp:`{g}` to calculate such bound. A very simple lower
- bound will be used in case this hook is not implemented: the total number
- of instructions divided by the issue rate.
-
-[TARGET_SCHED_SMS_RES_MII]
-
-[TARGET_SCHED_DISPATCH_DO]
-.. function:: void TARGET_SCHED_DISPATCH_DO (rtx_insn *insn, int x)
-
- This hook is called by Haifa Scheduler. It performs the operation specified
- in its second parameter.
-
-[TARGET_SCHED_DISPATCH_DO]
-
-[TARGET_SCHED_DISPATCH]
-.. function:: bool TARGET_SCHED_DISPATCH (rtx_insn *insn, int x)
-
- This hook is called by Haifa Scheduler. It returns true if dispatch scheduling
- is supported in hardware and the condition specified in the parameter is true.
-
-[TARGET_SCHED_DISPATCH]
-
-[TARGET_SCHED_EXPOSED_PIPELINE]
-.. c:var:: bool TARGET_SCHED_EXPOSED_PIPELINE
-
- True if the processor has an exposed pipeline, which means that not just
- the order of instructions is important for correctness when scheduling, but
- also the latencies of operations.
-
-[TARGET_SCHED_EXPOSED_PIPELINE]
-
-[TARGET_SCHED_REASSOCIATION_WIDTH]
-.. function:: int TARGET_SCHED_REASSOCIATION_WIDTH (unsigned int opc, machine_mode mode)
-
- This hook is called by tree reassociator to determine a level of
- parallelism required in output calculations chain.
-
-[TARGET_SCHED_REASSOCIATION_WIDTH]
-
-[TARGET_SCHED_FUSION_PRIORITY]
-.. function:: void TARGET_SCHED_FUSION_PRIORITY (rtx_insn *insn, int max_pri, int *fusion_pri, int *pri)
-
- This hook is called by scheduling fusion pass. It calculates fusion
- priorities for each instruction passed in by parameter. The priorities
- are returned via pointer parameters.
-
- :samp:`{insn}` is the instruction whose priorities need to be calculated.
- :samp:`{max_pri}` is the maximum priority can be returned in any cases.
- :samp:`{fusion_pri}` is the pointer parameter through which :samp:`{insn}` 's
- fusion priority should be calculated and returned.
- :samp:`{pri}` is the pointer parameter through which :samp:`{insn}` 's priority
- should be calculated and returned.
-
- Same :samp:`{fusion_pri}` should be returned for instructions which should
- be scheduled together. Different :samp:`{pri}` should be returned for
- instructions with same :samp:`{fusion_pri}`. :samp:`{fusion_pri}` is the major
- sort key, :samp:`{pri}` is the minor sort key. All instructions will be
- scheduled according to the two priorities. All priorities calculated
- should be between 0 (exclusive) and :samp:`{max_pri}` (inclusive). To avoid
- false dependencies, :samp:`{fusion_pri}` of instructions which need to be
- scheduled together should be smaller than :samp:`{fusion_pri}` of irrelevant
- instructions.
-
- Given below example:
-
- .. code-block:: c++
-
- ldr r10, [r1, 4]
- add r4, r4, r10
- ldr r15, [r2, 8]
- sub r5, r5, r15
- ldr r11, [r1, 0]
- add r4, r4, r11
- ldr r16, [r2, 12]
- sub r5, r5, r16
-
- On targets like ARM/AArch64, the two pairs of consecutive loads should be
- merged. Since peephole2 pass can't help in this case unless consecutive
- loads are actually next to each other in instruction flow. That's where
- this scheduling fusion pass works. This hook calculates priority for each
- instruction based on its fustion type, like:
-
- .. code-block:: c++
-
- ldr r10, [r1, 4] ; fusion_pri=99, pri=96
- add r4, r4, r10 ; fusion_pri=100, pri=100
- ldr r15, [r2, 8] ; fusion_pri=98, pri=92
- sub r5, r5, r15 ; fusion_pri=100, pri=100
- ldr r11, [r1, 0] ; fusion_pri=99, pri=100
- add r4, r4, r11 ; fusion_pri=100, pri=100
- ldr r16, [r2, 12] ; fusion_pri=98, pri=88
- sub r5, r5, r16 ; fusion_pri=100, pri=100
-
- Scheduling fusion pass then sorts all ready to issue instructions according
- to the priorities. As a result, instructions of same fusion type will be
- pushed together in instruction flow, like:
-
- .. code-block:: c++
-
- ldr r11, [r1, 0]
- ldr r10, [r1, 4]
- ldr r15, [r2, 8]
- ldr r16, [r2, 12]
- add r4, r4, r10
- sub r5, r5, r15
- add r4, r4, r11
- sub r5, r5, r16
-
- Now peephole2 pass can simply merge the two pairs of loads.
-
- Since scheduling fusion pass relies on peephole2 to do real fusion
- work, it is only enabled by default when peephole2 is in effect.
-
- This is firstly introduced on ARM/AArch64 targets, please refer to
- the hook implementation for how different fusion types are supported.
-
-[TARGET_SCHED_FUSION_PRIORITY]
-
-[TARGET_SIMD_CLONE_COMPUTE_VECSIZE_AND_SIMDLEN]
-.. function:: int TARGET_SIMD_CLONE_COMPUTE_VECSIZE_AND_SIMDLEN (struct cgraph_node *, struct cgraph_simd_clone *, tree, int)
-
- This hook should set :samp:`{vecsize_mangle}`, :samp:`{vecsize_int}`, :samp:`{vecsize_float}`
- fields in :samp:`{simd_clone}` structure pointed by :samp:`{clone_info}` argument and also
- :samp:`{simdlen}` field if it was previously 0.
- :samp:`{vecsize_mangle}` is a marker for the backend only. :samp:`{vecsize_int}` and
- :samp:`{vecsize_float}` should be left zero on targets where the number of lanes is
- not determined by the bitsize (in which case :samp:`{simdlen}` is always used).
- The hook should return 0 if SIMD clones shouldn't be emitted,
- or number of :samp:`{vecsize_mangle}` variants that should be emitted.
-
-[TARGET_SIMD_CLONE_COMPUTE_VECSIZE_AND_SIMDLEN]
-
-[TARGET_SIMD_CLONE_ADJUST]
-.. function:: void TARGET_SIMD_CLONE_ADJUST (struct cgraph_node *)
-
- This hook should add implicit ``attribute(target("..."))`` attribute
- to SIMD clone :samp:`{node}` if needed.
-
-[TARGET_SIMD_CLONE_ADJUST]
-
-[TARGET_SIMD_CLONE_USABLE]
-.. function:: int TARGET_SIMD_CLONE_USABLE (struct cgraph_node *)
-
- This hook should return -1 if SIMD clone :samp:`{node}` shouldn't be used
- in vectorized loops in current function, or non-negative number if it is
- usable. In that case, the smaller the number is, the more desirable it is
- to use it.
-
-[TARGET_SIMD_CLONE_USABLE]
-
-[TARGET_SIMT_VF]
-.. function:: int TARGET_SIMT_VF (void)
-
- Return number of threads in SIMT thread group on the target.
-
-[TARGET_SIMT_VF]
-
-[TARGET_OMP_DEVICE_KIND_ARCH_ISA]
-.. function:: int TARGET_OMP_DEVICE_KIND_ARCH_ISA (enum omp_device_kind_arch_isa trait, const char *name)
-
- Return 1 if :samp:`{trait}` :samp:`{name}` is present in the OpenMP context's
- device trait set, return 0 if not present in any OpenMP context in the
- whole translation unit, or -1 if not present in the current OpenMP context
- but might be present in another OpenMP context in the same TU.
-
-[TARGET_OMP_DEVICE_KIND_ARCH_ISA]
-
-[TARGET_GOACC_VALIDATE_DIMS]
-.. function:: bool TARGET_GOACC_VALIDATE_DIMS (tree decl, int *dims, int fn_level, unsigned used)
-
- This hook should check the launch dimensions provided for an OpenACC
- compute region, or routine. Defaulted values are represented as -1
- and non-constant values as 0. The :samp:`{fn_level}` is negative for the
- function corresponding to the compute region. For a routine it is the
- outermost level at which partitioned execution may be spawned. The hook
- should verify non-default values. If DECL is NULL, global defaults
- are being validated and unspecified defaults should be filled in.
- Diagnostics should be issued as appropriate. Return
- true, if changes have been made. You must override this hook to
- provide dimensions larger than 1.
-
-[TARGET_GOACC_VALIDATE_DIMS]
-
-[TARGET_GOACC_DIM_LIMIT]
-.. function:: int TARGET_GOACC_DIM_LIMIT (int axis)
-
- This hook should return the maximum size of a particular dimension,
- or zero if unbounded.
-
-[TARGET_GOACC_DIM_LIMIT]
-
-[TARGET_GOACC_FORK_JOIN]
-.. function:: bool TARGET_GOACC_FORK_JOIN (gcall *call, const int *dims, bool is_fork)
-
- This hook can be used to convert IFN_GOACC_FORK and IFN_GOACC_JOIN
- function calls to target-specific gimple, or indicate whether they
- should be retained. It is executed during the oacc_device_lower pass.
- It should return true, if the call should be retained. It should
- return false, if it is to be deleted (either because target-specific
- gimple has been inserted before it, or there is no need for it).
- The default hook returns false, if there are no RTL expanders for them.
-
-[TARGET_GOACC_FORK_JOIN]
-
-[TARGET_GOACC_REDUCTION]
-.. function:: void TARGET_GOACC_REDUCTION (gcall *call)
-
- This hook is used by the oacc_transform pass to expand calls to the
- :samp:`{GOACC_REDUCTION}` internal function, into a sequence of gimple
- instructions. :samp:`{call}` is gimple statement containing the call to
- the function. This hook removes statement :samp:`{call}` after the
- expanded sequence has been inserted. This hook is also responsible
- for allocating any storage for reductions when necessary.
-
-[TARGET_GOACC_REDUCTION]
-
-[TARGET_GOACC_ADJUST_PRIVATE_DECL]
-.. function:: tree TARGET_GOACC_ADJUST_PRIVATE_DECL (location_t loc, tree var, int 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
- parallelism level (i.e. ``GOMP_DIM_GANG``, ``GOMP_DIM_WORKER`` or
- ``GOMP_DIM_VECTOR``). A typical use for this hook is to force variable
- declarations at the ``gang`` level to reside in GPU shared memory.
- :samp:`{loc}` may be used for diagnostic purposes.
-
- You may also use the ``TARGET_GOACC_EXPAND_VAR_DECL`` hook if the
- adjusted variable declaration needs to be expanded to RTL in a non-standard
- way.
-
-[TARGET_GOACC_ADJUST_PRIVATE_DECL]
-
-[TARGET_GOACC_EXPAND_VAR_DECL]
-.. function:: rtx TARGET_GOACC_EXPAND_VAR_DECL (tree var)
-
- This hook, if defined, is used by accelerator target back-ends to expand
- specially handled kinds of ``VAR_DECL`` expressions. A particular use is
- to place variables with specific attributes inside special accelarator
- memories. A return value of ``NULL`` indicates that the target does not
- handle this ``VAR_DECL``, and normal RTL expanding is resumed.
-
- Only define this hook if your accelerator target needs to expand certain
- ``VAR_DECL`` nodes in a way that differs from the default. You can also adjust
- private variables at OpenACC device-lowering time using the
- ``TARGET_GOACC_ADJUST_PRIVATE_DECL`` target hook.
-
-[TARGET_GOACC_EXPAND_VAR_DECL]
-
-[TARGET_GOACC_CREATE_WORKER_BROADCAST_RECORD]
-.. function:: tree TARGET_GOACC_CREATE_WORKER_BROADCAST_RECORD (tree rec, bool sender, const char *name, unsigned HOST_WIDE_INT offset)
-
- Create a record used to propagate local-variable state from an active
- worker to other workers. A possible implementation might adjust the type
- of REC to place the new variable in shared GPU memory.
-
- Presence of this target hook indicates that middle end neutering/broadcasting
- be used.
-
-[TARGET_GOACC_CREATE_WORKER_BROADCAST_RECORD]
-
-[TARGET_GOACC_SHARED_MEM_LAYOUT]
-.. function:: void TARGET_GOACC_SHARED_MEM_LAYOUT (unsigned HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, int[], unsigned HOST_WIDE_INT[], unsigned HOST_WIDE_INT[])
-
- Lay out a fixed shared-memory region on the target. The LO and HI
- arguments should be set to a range of addresses that can be used for worker
- broadcasting. The dimensions, reduction size and gang-private size
- arguments are for the current offload region.
-
-[TARGET_GOACC_SHARED_MEM_LAYOUT]
-
-[TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD]
-.. function:: tree TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD (void)
-
- This hook should return the DECL of a function :samp:`{f}` that given an
- address :samp:`{addr}` as an argument returns a mask :samp:`{m}` that can be
- used to extract from two vectors the relevant data that resides in
- :samp:`{addr}` in case :samp:`{addr}` is not properly aligned.
-
- The autovectorizer, when vectorizing a load operation from an address
- :samp:`{addr}` that may be unaligned, will generate two vector loads from
- the two aligned addresses around :samp:`{addr}`. It then generates a
- ``REALIGN_LOAD`` operation to extract the relevant data from the
- two loaded vectors. The first two arguments to ``REALIGN_LOAD``,
- :samp:`{v1}` and :samp:`{v2}`, are the two vectors, each of size :samp:`{VS}`, and
- the third argument, :samp:`{OFF}`, defines how the data will be extracted
- from these two vectors: if :samp:`{OFF}` is 0, then the returned vector is
- :samp:`{v2}` ; otherwise, the returned vector is composed from the last
- :samp:`{VS}` - :samp:`{OFF}` elements of :samp:`{v1}` concatenated to the first
- :samp:`{OFF}` elements of :samp:`{v2}`.
-
- If this hook is defined, the autovectorizer will generate a call
- to :samp:`{f}` (using the DECL tree that this hook returns) and will
- use the return value of :samp:`{f}` as the argument :samp:`{OFF}` to
- ``REALIGN_LOAD``. Therefore, the mask :samp:`{m}` returned by :samp:`{f}`
- should comply with the semantics expected by ``REALIGN_LOAD``
- described above.
- If this hook is not defined, then :samp:`{addr}` will be used as
- the argument :samp:`{OFF}` to ``REALIGN_LOAD``, in which case the low
- log2(:samp:`{VS}`) - 1 bits of :samp:`{addr}` will be considered.
-
-[TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD]
-
-[TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION]
-.. function:: tree TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION (unsigned code, tree vec_type_out, tree vec_type_in)
-
- This hook should return the decl of a function that implements the
- vectorized variant of the function with the ``combined_fn`` code
- :samp:`{code}` or ``NULL_TREE`` if such a function is not available.
- The return type of the vectorized function shall be of vector type
- :samp:`{vec_type_out}` and the argument types should be :samp:`{vec_type_in}`.
-
-[TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION]
-
-[TARGET_VECTORIZE_BUILTIN_MD_VECTORIZED_FUNCTION]
-.. function:: tree TARGET_VECTORIZE_BUILTIN_MD_VECTORIZED_FUNCTION (tree fndecl, tree vec_type_out, tree vec_type_in)
-
- This hook should return the decl of a function that implements the
- vectorized variant of target built-in function ``fndecl``. The
- return type of the vectorized function shall be of vector type
- :samp:`{vec_type_out}` and the argument types should be :samp:`{vec_type_in}`.
-
-[TARGET_VECTORIZE_BUILTIN_MD_VECTORIZED_FUNCTION]
-
-[TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST]
-.. function:: int TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST (enum vect_cost_for_stmt type_of_cost, tree vectype, int misalign)
-
- Returns cost of different scalar or vector statements for vectorization cost model.
- For vector memory operations the cost may depend on type (:samp:`{vectype}`) and
- misalignment value (:samp:`{misalign}`).
-
-[TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST]
-
-[TARGET_VECTORIZE_PREFERRED_VECTOR_ALIGNMENT]
-.. function:: poly_uint64 TARGET_VECTORIZE_PREFERRED_VECTOR_ALIGNMENT (const_tree type)
-
- This hook returns the preferred alignment in bits for accesses to
- vectors of type :samp:`{type}` in vectorized code. This might be less than
- or greater than the ABI-defined value returned by
- ``TARGET_VECTOR_ALIGNMENT``. It can be equal to the alignment of
- a single element, in which case the vectorizer will not try to optimize
- for alignment.
-
- The default hook returns ``TYPE_ALIGN (type)``, which is
- correct for most targets.
-
-[TARGET_VECTORIZE_PREFERRED_VECTOR_ALIGNMENT]
-
-[TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE]
-.. function:: bool TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE (const_tree type, bool is_packed)
-
- Return true if vector alignment is reachable (by peeling N iterations)
- for the given scalar type :samp:`{type}`. :samp:`{is_packed}` is false if the scalar
- access using :samp:`{type}` is known to be naturally aligned.
-
-[TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE]
-
-[TARGET_VECTORIZE_VEC_PERM_CONST]
-.. function:: bool TARGET_VECTORIZE_VEC_PERM_CONST (machine_mode mode, machine_mode op_mode, rtx output, rtx in0, rtx in1, const vec_perm_indices &sel)
-
- This hook is used to test whether the target can permute up to two
- vectors of mode :samp:`{op_mode}` using the permutation vector ``sel``,
- producing a vector of mode :samp:`{mode}`. The hook is also used to emit such
- a permutation.
-
- When the hook is being used to test whether the target supports a permutation,
- :samp:`{in0}`, :samp:`{in1}`, and :samp:`{out}` are all null. When the hook is being used
- to emit a permutation, :samp:`{in0}` and :samp:`{in1}` are the source vectors of mode
- :samp:`{op_mode}` and :samp:`{out}` is the destination vector of mode :samp:`{mode}`.
- :samp:`{in1}` is the same as :samp:`{in0}` if :samp:`{sel}` describes a permutation on one
- vector instead of two.
-
- Return true if the operation is possible, emitting instructions for it
- if rtxes are provided.
-
- .. index:: vec_permm instruction pattern
-
- If the hook returns false for a mode with multibyte elements, GCC will
- try the equivalent byte operation. If that also fails, it will try forcing
- the selector into a register and using the :samp:`{vec_perm {mode} }`
- instruction pattern. There is no need for the hook to handle these two
- implementation approaches itself.
-
-[TARGET_VECTORIZE_VEC_PERM_CONST]
-
-[TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT]
-.. function:: bool TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT (machine_mode mode, const_tree type, int misalignment, bool is_packed)
-
- This hook should return true if the target supports misaligned vector
- store/load of a specific factor denoted in the :samp:`{misalignment}`
- parameter. The vector store/load should be of machine mode :samp:`{mode}` and
- the elements in the vectors should be of type :samp:`{type}`. :samp:`{is_packed}`
- parameter is true if the memory access is defined in a packed struct.
-
-[TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT]
-
-[TARGET_VECTORIZE_PREFERRED_SIMD_MODE]
-.. function:: machine_mode TARGET_VECTORIZE_PREFERRED_SIMD_MODE (scalar_mode mode)
-
- This hook should return the preferred mode for vectorizing scalar
- mode :samp:`{mode}`. The default is
- equal to ``word_mode``, because the vectorizer can do some
- transformations even in absence of specialized SIMD hardware.
-
-[TARGET_VECTORIZE_PREFERRED_SIMD_MODE]
-
-[TARGET_VECTORIZE_SPLIT_REDUCTION]
-.. function:: machine_mode TARGET_VECTORIZE_SPLIT_REDUCTION (machine_mode)
-
- This hook should return the preferred mode to split the final reduction
- step on :samp:`{mode}` to. The reduction is then carried out reducing upper
- against lower halves of vectors recursively until the specified mode is
- reached. The default is :samp:`{mode}` which means no splitting.
-
-[TARGET_VECTORIZE_SPLIT_REDUCTION]
-
-[TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES]
-.. function:: unsigned int TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES (vector_modes *modes, bool all)
-
- If using the mode returned by ``TARGET_VECTORIZE_PREFERRED_SIMD_MODE``
- is not the only approach worth considering, this hook should add one mode to
- :samp:`{modes}` for each useful alternative approach. These modes are then
- passed to ``TARGET_VECTORIZE_RELATED_MODE`` to obtain the vector mode
- for a given element mode.
-
- The modes returned in :samp:`{modes}` should use the smallest element mode
- possible for the vectorization approach that they represent, preferring
- integer modes over floating-poing modes in the event of a tie. The first
- mode should be the ``TARGET_VECTORIZE_PREFERRED_SIMD_MODE`` for its
- element mode.
-
- If :samp:`{all}` is true, add suitable vector modes even when they are generally
- not expected to be worthwhile.
-
- The hook returns a bitmask of flags that control how the modes in
- :samp:`{modes}` are used. The flags are:
-
- .. envvar:: VECT_COMPARE_COSTS
-
- Tells the loop vectorizer to try all the provided modes and pick the one
- with the lowest cost. By default the vectorizer will choose the first
- mode that works.
-
- The hook does not need to do anything if the vector returned by
- ``TARGET_VECTORIZE_PREFERRED_SIMD_MODE`` is the only one relevant
- for autovectorization. The default implementation adds no modes and
- returns 0.
-
-[TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES]
-
-[TARGET_VECTORIZE_RELATED_MODE]
-.. function:: opt_machine_mode TARGET_VECTORIZE_RELATED_MODE (machine_mode vector_mode, scalar_mode element_mode, poly_uint64 nunits)
-
- If a piece of code is using vector mode :samp:`{vector_mode}` and also wants
- to operate on elements of mode :samp:`{element_mode}`, return the vector mode
- it should use for those elements. If :samp:`{nunits}` is nonzero, ensure that
- the mode has exactly :samp:`{nunits}` elements, otherwise pick whichever vector
- size pairs the most naturally with :samp:`{vector_mode}`. Return an empty
- ``opt_machine_mode`` if there is no supported vector mode with the
- required properties.
-
- There is no prescribed way of handling the case in which :samp:`{nunits}`
- is zero. One common choice is to pick a vector mode with the same size
- as :samp:`{vector_mode}` ; this is the natural choice if the target has a
- fixed vector size. Another option is to choose a vector mode with the
- same number of elements as :samp:`{vector_mode}` ; this is the natural choice
- if the target has a fixed number of elements. Alternatively, the hook
- might choose a middle ground, such as trying to keep the number of
- elements as similar as possible while applying maximum and minimum
- vector sizes.
-
- The default implementation uses ``mode_for_vector`` to find the
- requested mode, returning a mode with the same size as :samp:`{vector_mode}`
- when :samp:`{nunits}` is zero. This is the correct behavior for most targets.
-
-[TARGET_VECTORIZE_RELATED_MODE]
-
-[TARGET_VECTORIZE_GET_MASK_MODE]
-.. function:: opt_machine_mode TARGET_VECTORIZE_GET_MASK_MODE (machine_mode mode)
-
- Return the mode to use for a vector mask that holds one boolean
- result for each element of vector mode :samp:`{mode}`. The returned mask mode
- can be a vector of integers (class ``MODE_VECTOR_INT``), a vector of
- booleans (class ``MODE_VECTOR_BOOL``) or a scalar integer (class
- ``MODE_INT``). Return an empty ``opt_machine_mode`` if no such
- mask mode exists.
-
- The default implementation returns a ``MODE_VECTOR_INT`` with the
- same size and number of elements as :samp:`{mode}`, if such a mode exists.
-
-[TARGET_VECTORIZE_GET_MASK_MODE]
-
-[TARGET_VECTORIZE_EMPTY_MASK_IS_EXPENSIVE]
-.. function:: bool TARGET_VECTORIZE_EMPTY_MASK_IS_EXPENSIVE (unsigned ifn)
-
- This hook returns true if masked internal function :samp:`{ifn}` (really of
- type ``internal_fn``) should be considered expensive when the mask is
- all zeros. GCC can then try to branch around the instruction instead.
-
-[TARGET_VECTORIZE_EMPTY_MASK_IS_EXPENSIVE]
-
-[TARGET_VECTORIZE_BUILTIN_GATHER]
-.. function:: tree TARGET_VECTORIZE_BUILTIN_GATHER (const_tree mem_vectype, const_tree index_type, int scale)
-
- Target builtin that implements vector gather operation. :samp:`{mem_vectype}`
- is the vector type of the load and :samp:`{index_type}` is scalar type of
- the index, scaled by :samp:`{scale}`.
- The default is ``NULL_TREE`` which means to not vectorize gather
- loads.
-
-[TARGET_VECTORIZE_BUILTIN_GATHER]
-
-[TARGET_VECTORIZE_BUILTIN_SCATTER]
-.. function:: tree TARGET_VECTORIZE_BUILTIN_SCATTER (const_tree vectype, const_tree index_type, int scale)
-
- Target builtin that implements vector scatter operation. :samp:`{vectype}`
- is the vector type of the store and :samp:`{index_type}` is scalar type of
- the index, scaled by :samp:`{scale}`.
- The default is ``NULL_TREE`` which means to not vectorize scatter
- stores.
-
-[TARGET_VECTORIZE_BUILTIN_SCATTER]
-
-[TARGET_VECTORIZE_CREATE_COSTS]
-.. function:: class vector_costs * TARGET_VECTORIZE_CREATE_COSTS (vec_info *vinfo, bool costing_for_scalar)
-
- This hook should initialize target-specific data structures in preparation
- for modeling the costs of vectorizing a loop or basic block. The default
- allocates three unsigned integers for accumulating costs for the prologue,
- body, and epilogue of the loop or basic block. If :samp:`{loop_info}` is
- non-NULL, it identifies the loop being vectorized; otherwise a single block
- is being vectorized. If :samp:`{costing_for_scalar}` is true, it indicates the
- current cost model is for the scalar version of a loop or block; otherwise
- it is for the vector version.
-
-[TARGET_VECTORIZE_CREATE_COSTS]
-
-[TARGET_PREFERRED_ELSE_VALUE]
-.. function:: tree TARGET_PREFERRED_ELSE_VALUE (unsigned ifn, tree type, unsigned nops, tree *ops)
-
- This hook returns the target's preferred final argument for a call
- to conditional internal function :samp:`{ifn}` (really of type
- ``internal_fn``). :samp:`{type}` specifies the return type of the
- function and :samp:`{ops}` are the operands to the conditional operation,
- of which there are :samp:`{nops}`.
-
- For example, if :samp:`{ifn}` is ``IFN_COND_ADD``, the hook returns
- a value of type :samp:`{type}` that should be used when :samp:`{ops}[0]`
- and :samp:`{ops}[1]` are conditionally added together.
-
- This hook is only relevant if the target supports conditional patterns
- like ``cond_addm``. The default implementation returns a zero
- constant of type :samp:`{type}`.
-
-[TARGET_PREFERRED_ELSE_VALUE]
-
-[TARGET_RECORD_OFFLOAD_SYMBOL]
-.. function:: void TARGET_RECORD_OFFLOAD_SYMBOL (tree)
-
- Used when offloaded functions are seen in the compilation unit and no named
- sections are available. It is called once for each symbol that must be
- recorded in the offload function and variable table.
-
-[TARGET_RECORD_OFFLOAD_SYMBOL]
-
-[TARGET_ABSOLUTE_BIGGEST_ALIGNMENT]
-.. c:var:: HOST_WIDE_INT TARGET_ABSOLUTE_BIGGEST_ALIGNMENT
-
- If defined, this target hook specifies the absolute biggest alignment
- that a type or variable can have on this machine, otherwise,
- ``BIGGEST_ALIGNMENT`` is used.
-
-[TARGET_ABSOLUTE_BIGGEST_ALIGNMENT]
-
-[TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE]
-.. function:: void TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE (void)
-
- This target function is similar to the hook ``TARGET_OPTION_OVERRIDE``
- but is called when the optimize level is changed via an attribute or
- pragma or when it is reset at the end of the code affected by the
- attribute or pragma. It is not called at the beginning of compilation
- when ``TARGET_OPTION_OVERRIDE`` is called so if you want to perform these
- actions then, you should have ``TARGET_OPTION_OVERRIDE`` call
- ``TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE``.
-
-[TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE]
-
-[TARGET_OFFLOAD_OPTIONS]
-.. function:: char * TARGET_OFFLOAD_OPTIONS (void)
-
- Used when writing out the list of options into an LTO file. It should
- translate any relevant target-specific options (such as the ABI in use)
- into one of the :option:`-foffload` options that exist as a common interface
- to express such options. It should return a string containing these options,
- separated by spaces, which the caller will free.
-
-[TARGET_OFFLOAD_OPTIONS]
-
-[TARGET_LIBGCC_CMP_RETURN_MODE]
-.. function:: scalar_int_mode TARGET_LIBGCC_CMP_RETURN_MODE (void)
-
- This target hook should return the mode to be used for the return value
- of compare instructions expanded to libgcc calls. If not defined
- ``word_mode`` is returned which is the right choice for a majority of
- targets.
-
-[TARGET_LIBGCC_CMP_RETURN_MODE]
-
-[TARGET_LIBGCC_SHIFT_COUNT_MODE]
-.. function:: scalar_int_mode TARGET_LIBGCC_SHIFT_COUNT_MODE (void)
-
- This target hook should return the mode to be used for the shift count operand
- of shift instructions expanded to libgcc calls. If not defined
- ``word_mode`` is returned which is the right choice for a majority of
- targets.
-
-[TARGET_LIBGCC_SHIFT_COUNT_MODE]
-
-[TARGET_UNWIND_WORD_MODE]
-.. function:: scalar_int_mode TARGET_UNWIND_WORD_MODE (void)
-
- Return machine mode to be used for ``_Unwind_Word`` type.
- The default is to use ``word_mode``.
-
-[TARGET_UNWIND_WORD_MODE]
-
-[TARGET_MERGE_DECL_ATTRIBUTES]
-.. function:: tree TARGET_MERGE_DECL_ATTRIBUTES (tree olddecl, tree newdecl)
-
- Define this target hook if the merging of decl attributes needs special
- handling. If defined, the result is a list of the combined
- ``DECL_ATTRIBUTES`` of :samp:`{olddecl}` and :samp:`{newdecl}`.
- :samp:`{newdecl}` is a duplicate declaration of :samp:`{olddecl}`. Examples of
- when this is needed are when one attribute overrides another, or when an
- attribute is nullified by a subsequent definition. This function may
- call ``merge_attributes`` to handle machine-independent merging.
-
- .. index:: TARGET_DLLIMPORT_DECL_ATTRIBUTES
-
- If the only target-specific handling you require is :samp:`dllimport`
- for Microsoft Windows targets, you should define the macro
- ``TARGET_DLLIMPORT_DECL_ATTRIBUTES`` to ``1``. The compiler
- will then define a function called
- ``merge_dllimport_decl_attributes`` which can then be defined as
- the expansion of ``TARGET_MERGE_DECL_ATTRIBUTES``. You can also
- add ``handle_dll_attribute`` in the attribute table for your port
- to perform initial processing of the :samp:`dllimport` and
- :samp:`dllexport` attributes. This is done in :samp:`i386/cygwin.h` and
- :samp:`i386/i386.cc`, for example.
-
-[TARGET_MERGE_DECL_ATTRIBUTES]
-
-[TARGET_MERGE_TYPE_ATTRIBUTES]
-.. function:: tree TARGET_MERGE_TYPE_ATTRIBUTES (tree type1, tree type2)
-
- Define this target hook if the merging of type attributes needs special
- handling. If defined, the result is a list of the combined
- ``TYPE_ATTRIBUTES`` of :samp:`{type1}` and :samp:`{type2}`. It is assumed
- that ``comptypes`` has already been called and returned 1. This
- function may call ``merge_attributes`` to handle machine-independent
- merging.
-
-[TARGET_MERGE_TYPE_ATTRIBUTES]
-
-[TARGET_ATTRIBUTE_TABLE]
-.. c:var:: const struct attribute_spec * TARGET_ATTRIBUTE_TABLE
-
- If defined, this target hook points to an array of :samp:`struct
- attribute_spec` (defined in :samp:`tree-core.h`) specifying the machine
- specific attributes for this target and some of the restrictions on the
- entities to which these attributes are applied and the arguments they
- take.
-
-[TARGET_ATTRIBUTE_TABLE]
-
-[TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P]
-.. function:: bool TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P (const_tree name)
-
- If defined, this target hook is a function which returns true if the
- machine-specific attribute named :samp:`{name}` expects an identifier
- given as its first argument to be passed on as a plain identifier, not
- subjected to name lookup. If this is not defined, the default is
- false for all machine-specific attributes.
-
-[TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P]
-
-[TARGET_COMP_TYPE_ATTRIBUTES]
-.. function:: int TARGET_COMP_TYPE_ATTRIBUTES (const_tree type1, const_tree type2)
-
- If defined, this target hook is a function which returns zero if the attributes on
- :samp:`{type1}` and :samp:`{type2}` are incompatible, one if they are compatible,
- and two if they are nearly compatible (which causes a warning to be
- generated). If this is not defined, machine-specific attributes are
- supposed always to be compatible.
-
-[TARGET_COMP_TYPE_ATTRIBUTES]
-
-[TARGET_SET_DEFAULT_TYPE_ATTRIBUTES]
-.. function:: void TARGET_SET_DEFAULT_TYPE_ATTRIBUTES (tree type)
-
- If defined, this target hook is a function which assigns default attributes to
- the newly defined :samp:`{type}`.
-
-[TARGET_SET_DEFAULT_TYPE_ATTRIBUTES]
-
-[TARGET_INSERT_ATTRIBUTES]
-.. function:: void TARGET_INSERT_ATTRIBUTES (tree node, tree *attr_ptr)
-
- Define this target hook if you want to be able to add attributes to a decl
- when it is being created. This is normally useful for back ends which
- wish to implement a pragma by using the attributes which correspond to
- the pragma's effect. The :samp:`{node}` argument is the decl which is being
- created. The :samp:`{attr_ptr}` argument is a pointer to the attribute list
- for this decl. The list itself should not be modified, since it may be
- shared with other decls, but attributes may be chained on the head of
- the list and ``*attr_ptr`` modified to point to the new
- attributes, or a copy of the list may be made if further changes are
- needed.
-
-[TARGET_INSERT_ATTRIBUTES]
-
-[TARGET_HANDLE_GENERIC_ATTRIBUTE]
-.. function:: tree TARGET_HANDLE_GENERIC_ATTRIBUTE (tree *node, tree name, tree args, int flags, bool *no_add_attrs)
-
- Define this target hook if you want to be able to perform additional
- target-specific processing of an attribute which is handled generically
- by a front end. The arguments are the same as those which are passed to
- attribute handlers. So far this only affects the :samp:`{noinit}` and
- :samp:`{section}` attribute.
-
-[TARGET_HANDLE_GENERIC_ATTRIBUTE]
-
-[TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P]
-.. function:: bool TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P (const_tree fndecl)
-
- .. index:: inlining
-
- This target hook returns ``true`` if it is OK to inline :samp:`{fndecl}`
- into the current function, despite its having target-specific
- attributes, ``false`` otherwise. By default, if a function has a
- target specific attribute attached to it, it will not be inlined.
-
-[TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P]
-
-[TARGET_MS_BITFIELD_LAYOUT_P]
-.. function:: bool TARGET_MS_BITFIELD_LAYOUT_P (const_tree record_type)
-
- This target hook returns ``true`` if bit-fields in the given
- :samp:`{record_type}` are to be laid out following the rules of Microsoft
- Visual C/C++, namely: (i) a bit-field won't share the same storage
- unit with the previous bit-field if their underlying types have
- different sizes, and the bit-field will be aligned to the highest
- alignment of the underlying types of itself and of the previous
- bit-field; (ii) a zero-sized bit-field will affect the alignment of
- the whole enclosing structure, even if it is unnamed; except that
- (iii) a zero-sized bit-field will be disregarded unless it follows
- another bit-field of nonzero size. If this hook returns ``true``,
- other macros that control bit-field layout are ignored.
-
- When a bit-field is inserted into a packed record, the whole size
- of the underlying type is used by one or more same-size adjacent
- bit-fields (that is, if its long:3, 32 bits is used in the record,
- and any additional adjacent long bit-fields are packed into the same
- chunk of 32 bits. However, if the size changes, a new field of that
- size is allocated). In an unpacked record, this is the same as using
- alignment, but not equivalent when packing.
-
- If both MS bit-fields and :samp:`__attribute__((packed))` are used,
- the latter will take precedence. If :samp:`__attribute__((packed))` is
- used on a single field when MS bit-fields are in use, it will take
- precedence for that field, but the alignment of the rest of the structure
- may affect its placement.
-
-[TARGET_MS_BITFIELD_LAYOUT_P]
-
-[TARGET_FLOAT_EXCEPTIONS_ROUNDING_SUPPORTED_P]
-.. function:: bool TARGET_FLOAT_EXCEPTIONS_ROUNDING_SUPPORTED_P (void)
-
- Returns true if the target supports IEEE 754 floating-point exceptions
- and rounding modes, false otherwise. This is intended to relate to the
- ``float`` and ``double`` types, but not necessarily ``long double``.
- By default, returns true if the ``adddf3`` instruction pattern is
- available and false otherwise, on the assumption that hardware floating
- point supports exceptions and rounding modes but software floating point
- does not.
-
-[TARGET_FLOAT_EXCEPTIONS_ROUNDING_SUPPORTED_P]
-
-[TARGET_DECIMAL_FLOAT_SUPPORTED_P]
-.. function:: bool TARGET_DECIMAL_FLOAT_SUPPORTED_P (void)
-
- Returns true if the target supports decimal floating point.
-
-[TARGET_DECIMAL_FLOAT_SUPPORTED_P]
-
-[TARGET_FIXED_POINT_SUPPORTED_P]
-.. function:: bool TARGET_FIXED_POINT_SUPPORTED_P (void)
-
- Returns true if the target supports fixed-point arithmetic.
-
-[TARGET_FIXED_POINT_SUPPORTED_P]
-
-[TARGET_ALIGN_ANON_BITFIELD]
-.. function:: bool TARGET_ALIGN_ANON_BITFIELD (void)
-
- When ``PCC_BITFIELD_TYPE_MATTERS`` is true this hook will determine
- whether unnamed bitfields affect the alignment of the containing
- structure. The hook should return true if the structure should inherit
- the alignment requirements of an unnamed bitfield's type.
-
-[TARGET_ALIGN_ANON_BITFIELD]
-
-[TARGET_NARROW_VOLATILE_BITFIELD]
-.. function:: bool TARGET_NARROW_VOLATILE_BITFIELD (void)
-
- This target hook should return ``true`` if accesses to volatile bitfields
- should use the narrowest mode possible. It should return ``false`` if
- these accesses should use the bitfield container type.
-
- The default is ``false``.
-
-[TARGET_NARROW_VOLATILE_BITFIELD]
-
-[TARGET_INIT_BUILTINS]
-.. function:: void TARGET_INIT_BUILTINS (void)
-
- Define this hook if you have any machine-specific built-in functions
- that need to be defined. It should be a function that performs the
- necessary setup.
-
- Machine specific built-in functions can be useful to expand special machine
- instructions that would otherwise not normally be generated because
- they have no equivalent in the source language (for example, SIMD vector
- instructions or prefetch instructions).
-
- To create a built-in function, call the function
- ``lang_hooks.builtin_function``
- which is defined by the language front end. You can use any type nodes set
- up by ``build_common_tree_nodes`` ;
- only language front ends that use those two functions will call
- :samp:`TARGET_INIT_BUILTINS`.
-
-[TARGET_INIT_BUILTINS]
-
-[TARGET_BUILTIN_DECL]
-.. function:: tree TARGET_BUILTIN_DECL (unsigned code, bool initialize_p)
-
- Define this hook if you have any machine-specific built-in functions
- that need to be defined. It should be a function that returns the
- builtin function declaration for the builtin function code :samp:`{code}`.
- If there is no such builtin and it cannot be initialized at this time
- if :samp:`{initialize_p}` is true the function should return ``NULL_TREE``.
- If :samp:`{code}` is out of range the function should return
- ``error_mark_node``.
-
-[TARGET_BUILTIN_DECL]
-
-[TARGET_EXPAND_BUILTIN]
-.. function:: rtx TARGET_EXPAND_BUILTIN (tree exp, rtx target, rtx subtarget, machine_mode mode, int ignore)
-
- Expand a call to a machine specific built-in function that was set up by
- :samp:`TARGET_INIT_BUILTINS`. :samp:`{exp}` is the expression for the
- function call; the result should go to :samp:`{target}` if that is
- convenient, and have mode :samp:`{mode}` if that is convenient.
- :samp:`{subtarget}` may be used as the target for computing one of
- :samp:`{exp}` 's operands. :samp:`{ignore}` is nonzero if the value is to be
- ignored. This function should return the result of the call to the
- built-in function.
-
-[TARGET_EXPAND_BUILTIN]
-
-[TARGET_RESOLVE_OVERLOADED_BUILTIN]
-.. function:: tree TARGET_RESOLVE_OVERLOADED_BUILTIN (unsigned int loc, tree fndecl, void *arglist)
-
- Select a replacement for a machine specific built-in function that
- was set up by :samp:`TARGET_INIT_BUILTINS`. This is done
- *before* regular type checking, and so allows the target to
- implement a crude form of function overloading. :samp:`{fndecl}` is the
- declaration of the built-in function. :samp:`{arglist}` is the list of
- arguments passed to the built-in function. The result is a
- complete expression that implements the operation, usually
- another ``CALL_EXPR``.
- :samp:`{arglist}` really has type :samp:`VEC(tree,gc)*`
-
-[TARGET_RESOLVE_OVERLOADED_BUILTIN]
-
-[TARGET_CHECK_BUILTIN_CALL]
-.. function:: bool TARGET_CHECK_BUILTIN_CALL (location_t loc, vec<location_t> arg_loc, tree fndecl, tree orig_fndecl, unsigned int nargs, tree *args)
-
- Perform semantic checking on a call to a machine-specific built-in
- function after its arguments have been constrained to the function
- signature. Return true if the call is valid, otherwise report an error
- and return false.
-
- This hook is called after ``TARGET_RESOLVE_OVERLOADED_BUILTIN``.
- The call was originally to built-in function :samp:`{orig_fndecl}`,
- but after the optional ``TARGET_RESOLVE_OVERLOADED_BUILTIN``
- step is now to built-in function :samp:`{fndecl}`. :samp:`{loc}` is the
- location of the call and :samp:`{args}` is an array of function arguments,
- of which there are :samp:`{nargs}`. :samp:`{arg_loc}` specifies the location
- of each argument.
-
-[TARGET_CHECK_BUILTIN_CALL]
-
-[TARGET_FOLD_BUILTIN]
-.. function:: tree TARGET_FOLD_BUILTIN (tree fndecl, int n_args, tree *argp, bool ignore)
-
- Fold a call to a machine specific built-in function that was set up by
- :samp:`TARGET_INIT_BUILTINS`. :samp:`{fndecl}` is the declaration of the
- built-in function. :samp:`{n_args}` is the number of arguments passed to
- the function; the arguments themselves are pointed to by :samp:`{argp}`.
- The result is another tree, valid for both GIMPLE and GENERIC,
- containing a simplified expression for the call's result. If
- :samp:`{ignore}` is true the value will be ignored.
-
-[TARGET_FOLD_BUILTIN]
-
-[TARGET_GIMPLE_FOLD_BUILTIN]
-.. function:: bool TARGET_GIMPLE_FOLD_BUILTIN (gimple_stmt_iterator *gsi)
-
- Fold a call to a machine specific built-in function that was set up
- by :samp:`TARGET_INIT_BUILTINS`. :samp:`{gsi}` points to the gimple
- statement holding the function call. Returns true if any change
- was made to the GIMPLE stream.
-
-[TARGET_GIMPLE_FOLD_BUILTIN]
-
-[TARGET_COMPARE_VERSION_PRIORITY]
-.. function:: int TARGET_COMPARE_VERSION_PRIORITY (tree decl1, tree decl2)
-
- This hook is used to compare the target attributes in two functions to
- determine which function's features get higher priority. This is used
- during function multi-versioning to figure out the order in which two
- versions must be dispatched. A function version with a higher priority
- is checked for dispatching earlier. :samp:`{decl1}` and :samp:`{decl2}` are
- the two function decls that will be compared.
-
-[TARGET_COMPARE_VERSION_PRIORITY]
-
-[TARGET_GENERATE_VERSION_DISPATCHER_BODY]
-.. function:: tree TARGET_GENERATE_VERSION_DISPATCHER_BODY (void *arg)
-
- This hook is used to generate the dispatcher logic to invoke the right
- function version at run-time for a given set of function versions.
- :samp:`{arg}` points to the callgraph node of the dispatcher function whose
- body must be generated.
-
-[TARGET_GENERATE_VERSION_DISPATCHER_BODY]
-
-[TARGET_GET_FUNCTION_VERSIONS_DISPATCHER]
-.. function:: tree TARGET_GET_FUNCTION_VERSIONS_DISPATCHER (void *decl)
-
- This hook is used to get the dispatcher function for a set of function
- versions. The dispatcher function is called to invoke the right function
- version at run-time. :samp:`{decl}` is one version from a set of semantically
- identical versions.
-
-[TARGET_GET_FUNCTION_VERSIONS_DISPATCHER]
-
-[TARGET_BUILTIN_RECIPROCAL]
-.. function:: tree TARGET_BUILTIN_RECIPROCAL (tree fndecl)
-
- This hook should return the DECL of a function that implements the
- reciprocal of the machine-specific builtin function :samp:`{fndecl}`, or
- ``NULL_TREE`` if such a function is not available.
-
-[TARGET_BUILTIN_RECIPROCAL]
-
-[TARGET_MANGLE_TYPE]
-.. function:: const char * TARGET_MANGLE_TYPE (const_tree type)
-
- If your target defines any fundamental types, or any types your target
- uses should be mangled differently from the default, define this hook
- to return the appropriate encoding for these types as part of a C++
- mangled name. The :samp:`{type}` argument is the tree structure representing
- the type to be mangled. The hook may be applied to trees which are
- not target-specific fundamental types; it should return ``NULL``
- for all such types, as well as arguments it does not recognize. If the
- return value is not ``NULL``, it must point to a statically-allocated
- string constant.
-
- Target-specific fundamental types might be new fundamental types or
- qualified versions of ordinary fundamental types. Encode new
- fundamental types as :samp:`u {n}{name}`, where :samp:`{name}`
- is the name used for the type in source code, and :samp:`{n}` is the
- length of :samp:`{name}` in decimal. Encode qualified versions of
- ordinary types as :samp:`U{n}{name}{code}`, where
- :samp:`{name}` is the name used for the type qualifier in source code,
- :samp:`{n}` is the length of :samp:`{name}` as above, and :samp:`{code}` is the
- code used to represent the unqualified version of this type. (See
- ``write_builtin_type`` in :samp:`cp/mangle.cc` for the list of
- codes.) In both cases the spaces are for clarity; do not include any
- spaces in your string.
-
- This hook is applied to types prior to typedef resolution. If the mangled
- name for a particular type depends only on that type's main variant, you
- can perform typedef resolution yourself using ``TYPE_MAIN_VARIANT``
- before mangling.
-
- The default version of this hook always returns ``NULL``, which is
- appropriate for a target that does not define any new fundamental
- types.
-
-[TARGET_MANGLE_TYPE]
-
-[TARGET_INIT_LIBFUNCS]
-.. function:: void TARGET_INIT_LIBFUNCS (void)
-
- This hook should declare additional library routines or rename
- existing ones, using the functions ``set_optab_libfunc`` and
- ``init_one_libfunc`` defined in :samp:`optabs.cc`.
- ``init_optabs`` calls this macro after initializing all the normal
- library routines.
-
- The default is to do nothing. Most ports don't need to define this hook.
-
-[TARGET_INIT_LIBFUNCS]
-
-[TARGET_LIBFUNC_GNU_PREFIX]
-.. c:var:: bool TARGET_LIBFUNC_GNU_PREFIX
-
- If false (the default), internal library routines start with two
- underscores. If set to true, these routines start with ``__gnu_``
- instead. E.g., ``__muldi3`` changes to ``__gnu_muldi3``. This
- currently only affects functions defined in :samp:`libgcc2.c`. If this
- is set to true, the :samp:`tm.h` file must also
- ``#define LIBGCC2_GNU_PREFIX``.
-
-[TARGET_LIBFUNC_GNU_PREFIX]
-
-[TARGET_SECTION_TYPE_FLAGS]
-.. function:: unsigned int TARGET_SECTION_TYPE_FLAGS (tree decl, const char *name, int reloc)
-
- Choose a set of section attributes for use by ``TARGET_ASM_NAMED_SECTION``
- based on a variable or function decl, a section name, and whether or not the
- declaration's initializer may contain runtime relocations. :samp:`{decl}` may be
- null, in which case read-write data should be assumed.
-
- The default version of this function handles choosing code vs data,
- read-only vs read-write data, and ``flag_pic``. You should only
- need to override this if your target has special flags that might be
- set via ``__attribute__``.
-
-[TARGET_SECTION_TYPE_FLAGS]
-
-[TARGET_LIBC_HAS_FUNCTION]
-.. function:: bool TARGET_LIBC_HAS_FUNCTION (enum function_class fn_class, tree type)
-
- This hook determines whether a function from a class of functions
- :samp:`{fn_class}` is present in the target C library. If :samp:`{type}` is NULL,
- the caller asks for support for all standard (float, double, long double)
- types. If :samp:`{type}` is non-NULL, the caller asks for support for a
- specific type.
-
-[TARGET_LIBC_HAS_FUNCTION]
-
-[TARGET_LIBC_HAS_FAST_FUNCTION]
-.. function:: bool TARGET_LIBC_HAS_FAST_FUNCTION (int fcode)
-
- This hook determines whether a function from a class of functions
- ``(enum function_class)``:samp:`{fcode}` has a fast implementation.
-
-[TARGET_LIBC_HAS_FAST_FUNCTION]
-
-[TARGET_CANNOT_MODIFY_JUMPS_P]
-.. function:: bool TARGET_CANNOT_MODIFY_JUMPS_P (void)
-
- This target hook returns ``true`` past the point in which new jump
- instructions could be created. On machines that require a register for
- every jump such as the SHmedia ISA of SH5, this point would typically be
- reload, so this target hook should be defined to a function such as:
-
- .. code-block:: c++
-
- static bool
- cannot_modify_jumps_past_reload_p ()
- {
- return (reload_completed || reload_in_progress);
- }
-
-[TARGET_CANNOT_MODIFY_JUMPS_P]
-
-[TARGET_CAN_FOLLOW_JUMP]
-.. function:: bool TARGET_CAN_FOLLOW_JUMP (const rtx_insn *follower, const rtx_insn *followee)
-
- FOLLOWER and FOLLOWEE are JUMP_INSN instructions;
- return true if FOLLOWER may be modified to follow FOLLOWEE;
- false, if it can't.
- For example, on some targets, certain kinds of branches can't be made to
- follow through a hot/cold partitioning.
-
-[TARGET_CAN_FOLLOW_JUMP]
-
-[TARGET_HAVE_CONDITIONAL_EXECUTION]
-.. function:: bool TARGET_HAVE_CONDITIONAL_EXECUTION (void)
-
- This target hook returns true if the target supports conditional execution.
- This target hook is required only when the target has several different
- modes and they have different conditional execution capability, such as ARM.
-
-[TARGET_HAVE_CONDITIONAL_EXECUTION]
-
-[TARGET_GEN_CCMP_FIRST]
-.. function:: rtx TARGET_GEN_CCMP_FIRST (rtx_insn **prep_seq, rtx_insn **gen_seq, int code, tree op0, tree op1)
-
- This function prepares to emit a comparison insn for the first compare in a
- sequence of conditional comparisions. It returns an appropriate comparison
- with ``CC`` for passing to ``gen_ccmp_next`` or ``cbranch_optab``.
- The insns to prepare the compare are saved in :samp:`{prep_seq}` and the compare
- insns are saved in :samp:`{gen_seq}`. They will be emitted when all the
- compares in the conditional comparision are generated without error.
- :samp:`{code}` is the ``rtx_code`` of the compare for :samp:`{op0}` and :samp:`{op1}`.
-
-[TARGET_GEN_CCMP_FIRST]
-
-[TARGET_GEN_CCMP_NEXT]
-.. function:: rtx TARGET_GEN_CCMP_NEXT (rtx_insn **prep_seq, rtx_insn **gen_seq, rtx prev, int cmp_code, tree op0, tree op1, int bit_code)
-
- This function prepares to emit a conditional comparison within a sequence
- of conditional comparisons. It returns an appropriate comparison with
- ``CC`` for passing to ``gen_ccmp_next`` or ``cbranch_optab``.
- The insns to prepare the compare are saved in :samp:`{prep_seq}` and the compare
- insns are saved in :samp:`{gen_seq}`. They will be emitted when all the
- compares in the conditional comparision are generated without error. The
- :samp:`{prev}` expression is the result of a prior call to ``gen_ccmp_first``
- or ``gen_ccmp_next``. It may return ``NULL`` if the combination of
- :samp:`{prev}` and this comparison is not supported, otherwise the result must
- be appropriate for passing to ``gen_ccmp_next`` or ``cbranch_optab``.
- :samp:`{code}` is the ``rtx_code`` of the compare for :samp:`{op0}` and :samp:`{op1}`.
- :samp:`{bit_code}` is ``AND`` or ``IOR``, which is the op on the compares.
-
-[TARGET_GEN_CCMP_NEXT]
-
-[TARGET_GEN_MEMSET_SCRATCH_RTX]
-.. function:: rtx TARGET_GEN_MEMSET_SCRATCH_RTX (machine_mode mode)
-
- This hook should return an rtx for a scratch register in :samp:`{mode}` to
- be used when expanding memset calls. The backend can use a hard scratch
- register to avoid stack realignment when expanding memset. The default
- is ``gen_reg_rtx``.
-
-[TARGET_GEN_MEMSET_SCRATCH_RTX]
-
-[TARGET_LOOP_UNROLL_ADJUST]
-.. function:: unsigned TARGET_LOOP_UNROLL_ADJUST (unsigned nunroll, class loop *loop)
-
- This target hook returns a new value for the number of times :samp:`{loop}`
- should be unrolled. The parameter :samp:`{nunroll}` is the number of times
- the loop is to be unrolled. The parameter :samp:`{loop}` is a pointer to
- the loop, which is going to be checked for unrolling. This target hook
- is required only when the target has special constraints like maximum
- number of memory accesses.
-
-[TARGET_LOOP_UNROLL_ADJUST]
-
-[TARGET_LEGITIMATE_CONSTANT_P]
-.. function:: bool TARGET_LEGITIMATE_CONSTANT_P (machine_mode mode, rtx x)
-
- This hook returns true if :samp:`{x}` is a legitimate constant for a
- :samp:`{mode}` -mode immediate operand on the target machine. You can assume that
- :samp:`{x}` satisfies ``CONSTANT_P``, so you need not check this.
-
- The default definition returns true.
-
-[TARGET_LEGITIMATE_CONSTANT_P]
-
-[TARGET_PRECOMPUTE_TLS_P]
-.. function:: bool TARGET_PRECOMPUTE_TLS_P (machine_mode mode, rtx x)
-
- This hook returns true if :samp:`{x}` is a TLS operand on the target
- machine that should be pre-computed when used as the argument in a call.
- You can assume that :samp:`{x}` satisfies ``CONSTANT_P``, so you need not
- check this.
-
- The default definition returns false.
-
-[TARGET_PRECOMPUTE_TLS_P]
-
-[TARGET_CANNOT_FORCE_CONST_MEM]
-.. function:: bool TARGET_CANNOT_FORCE_CONST_MEM (machine_mode mode, rtx x)
-
- This hook should return true if :samp:`{x}` is of a form that cannot (or
- should not) be spilled to the constant pool. :samp:`{mode}` is the mode
- of :samp:`{x}`.
-
- The default version of this hook returns false.
-
- The primary reason to define this hook is to prevent reload from
- deciding that a non-legitimate constant would be better reloaded
- from the constant pool instead of spilling and reloading a register
- holding the constant. This restriction is often true of addresses
- of TLS symbols for various targets.
-
-[TARGET_CANNOT_FORCE_CONST_MEM]
-
-[TARGET_COMMUTATIVE_P]
-.. function:: bool TARGET_COMMUTATIVE_P (const_rtx x, int outer_code)
-
- This target hook returns ``true`` if :samp:`{x}` is considered to be commutative.
- Usually, this is just COMMUTATIVE_P (:samp:`{x}`), but the HP PA doesn't consider
- PLUS to be commutative inside a MEM. :samp:`{outer_code}` is the rtx code
- of the enclosing rtl, if known, otherwise it is UNKNOWN.
-
-[TARGET_COMMUTATIVE_P]
-
-[TARGET_MODE_DEPENDENT_ADDRESS_P]
-.. function:: bool TARGET_MODE_DEPENDENT_ADDRESS_P (const_rtx addr, addr_space_t addrspace)
-
- This hook returns ``true`` if memory address :samp:`{addr}` in address
- space :samp:`{addrspace}` can have
- different meanings depending on the machine mode of the memory
- reference it is used for or if the address is valid for some modes
- but not others.
-
- Autoincrement and autodecrement addresses typically have mode-dependent
- effects because the amount of the increment or decrement is the size
- of the operand being addressed. Some machines have other mode-dependent
- addresses. Many RISC machines have no mode-dependent addresses.
-
- You may assume that :samp:`{addr}` is a valid address for the machine.
-
- The default version of this hook returns ``false``.
-
-[TARGET_MODE_DEPENDENT_ADDRESS_P]
-
-[TARGET_LEGITIMIZE_ADDRESS]
-.. function:: rtx TARGET_LEGITIMIZE_ADDRESS (rtx x, rtx oldx, machine_mode mode)
-
- This hook is given an invalid memory address :samp:`{x}` for an
- operand of mode :samp:`{mode}` and should try to return a valid memory
- address.
-
- .. index:: break_out_memory_refs
-
- :samp:`{x}` will always be the result of a call to ``break_out_memory_refs``,
- and :samp:`{oldx}` will be the operand that was given to that function to produce
- :samp:`{x}`.
-
- The code of the hook should not alter the substructure of
- :samp:`{x}`. If it transforms :samp:`{x}` into a more legitimate form, it
- should return the new :samp:`{x}`.
-
- It is not necessary for this hook to come up with a legitimate address,
- with the exception of native TLS addresses (see :ref:`emulated-tls`).
- The compiler has standard ways of doing so in all cases. In fact, if
- the target supports only emulated TLS, it
- is safe to omit this hook or make it return :samp:`{x}` if it cannot find
- a valid way to legitimize the address. But often a machine-dependent
- strategy can generate better code.
-
-[TARGET_LEGITIMIZE_ADDRESS]
-
-[TARGET_DELEGITIMIZE_ADDRESS]
-.. function:: rtx TARGET_DELEGITIMIZE_ADDRESS (rtx x)
-
- This hook is used to undo the possibly obfuscating effects of the
- ``LEGITIMIZE_ADDRESS`` and ``LEGITIMIZE_RELOAD_ADDRESS`` target
- macros. Some backend implementations of these macros wrap symbol
- references inside an ``UNSPEC`` rtx to represent PIC or similar
- addressing modes. This target hook allows GCC's optimizers to understand
- the semantics of these opaque ``UNSPEC`` s by converting them back
- into their original form.
-
-[TARGET_DELEGITIMIZE_ADDRESS]
-
-[TARGET_CONST_NOT_OK_FOR_DEBUG_P]
-.. function:: bool TARGET_CONST_NOT_OK_FOR_DEBUG_P (rtx x)
-
- This hook should return true if :samp:`{x}` should not be emitted into
- debug sections.
-
-[TARGET_CONST_NOT_OK_FOR_DEBUG_P]
-
-[TARGET_LEGITIMATE_ADDRESS_P]
-.. function:: bool TARGET_LEGITIMATE_ADDRESS_P (machine_mode mode, rtx x, bool strict)
-
- A function that returns whether :samp:`{x}` (an RTX) is a legitimate memory
- address on the target machine for a memory operand of mode :samp:`{mode}`.
-
- Legitimate addresses are defined in two variants: a strict variant and a
- non-strict one. The :samp:`{strict}` parameter chooses which variant is
- desired by the caller.
-
- The strict variant is used in the reload pass. It must be defined so
- that any pseudo-register that has not been allocated a hard register is
- considered a memory reference. This is because in contexts where some
- kind of register is required, a pseudo-register with no hard register
- must be rejected. For non-hard registers, the strict variant should look
- up the ``reg_renumber`` array; it should then proceed using the hard
- register number in the array, or treat the pseudo as a memory reference
- if the array holds ``-1``.
-
- The non-strict variant is used in other passes. It must be defined to
- accept all pseudo-registers in every context where some kind of
- register is required.
-
- Normally, constant addresses which are the sum of a ``symbol_ref``
- and an integer are stored inside a ``const`` RTX to mark them as
- constant. Therefore, there is no need to recognize such sums
- specifically as legitimate addresses. Normally you would simply
- recognize any ``const`` as legitimate.
-
- Usually ``PRINT_OPERAND_ADDRESS`` is not prepared to handle constant
- sums that are not marked with ``const``. It assumes that a naked
- ``plus`` indicates indexing. If so, then you *must* reject such
- naked constant sums as illegitimate addresses, so that none of them will
- be given to ``PRINT_OPERAND_ADDRESS``.
-
- .. index:: TARGET_ENCODE_SECTION_INFO and address validation
-
- On some machines, whether a symbolic address is legitimate depends on
- the section that the address refers to. On these machines, define the
- target hook ``TARGET_ENCODE_SECTION_INFO`` to store the information
- into the ``symbol_ref``, and then check for it here. When you see a
- ``const``, you will have to look inside it to find the
- ``symbol_ref`` in order to determine the section. See :ref:`assembler-format`.
-
- .. index:: GO_IF_LEGITIMATE_ADDRESS
-
- Some ports are still using a deprecated legacy substitute for
- this hook, the ``GO_IF_LEGITIMATE_ADDRESS`` macro. This macro
- has this syntax:
-
- .. code-block:: c++
-
- #define GO_IF_LEGITIMATE_ADDRESS (mode, x, label)
-
- and should ``goto label`` if the address :samp:`{x}` is a valid
- address on the target machine for a memory operand of mode :samp:`{mode}`.
-
- .. index:: REG_OK_STRICT
-
- Compiler source files that want to use the strict variant of this
- macro define the macro ``REG_OK_STRICT``. You should use an
- ``#ifdef REG_OK_STRICT`` conditional to define the strict variant in
- that case and the non-strict variant otherwise.
-
- Using the hook is usually simpler because it limits the number of
- files that are recompiled when changes are made.
-
-[TARGET_LEGITIMATE_ADDRESS_P]
-
-[TARGET_USE_BLOCKS_FOR_CONSTANT_P]
-.. function:: bool TARGET_USE_BLOCKS_FOR_CONSTANT_P (machine_mode mode, const_rtx x)
-
- This hook should return true if pool entries for constant :samp:`{x}` can
- be placed in an ``object_block`` structure. :samp:`{mode}` is the mode
- of :samp:`{x}`.
-
- The default version returns false for all constants.
-
-[TARGET_USE_BLOCKS_FOR_CONSTANT_P]
-
-[TARGET_USE_BLOCKS_FOR_DECL_P]
-.. function:: bool TARGET_USE_BLOCKS_FOR_DECL_P (const_tree decl)
-
- This hook should return true if pool entries for :samp:`{decl}` should
- be placed in an ``object_block`` structure.
-
- The default version returns true for all decls.
-
-[TARGET_USE_BLOCKS_FOR_DECL_P]
-
-[TARGET_MIN_ANCHOR_OFFSET]
-.. c:var:: HOST_WIDE_INT TARGET_MIN_ANCHOR_OFFSET
-
- The minimum offset that should be applied to a section anchor.
- On most targets, it should be the smallest offset that can be
- applied to a base register while still giving a legitimate address
- for every mode. The default value is 0.
-
-[TARGET_MIN_ANCHOR_OFFSET]
-
-[TARGET_MAX_ANCHOR_OFFSET]
-.. c:var:: HOST_WIDE_INT TARGET_MAX_ANCHOR_OFFSET
-
- Like ``TARGET_MIN_ANCHOR_OFFSET``, but the maximum (inclusive)
- offset that should be applied to section anchors. The default
- value is 0.
-
-[TARGET_MAX_ANCHOR_OFFSET]
-
-[TARGET_USE_ANCHORS_FOR_SYMBOL_P]
-.. function:: bool TARGET_USE_ANCHORS_FOR_SYMBOL_P (const_rtx x)
-
- Return true if GCC should attempt to use anchors to access ``SYMBOL_REF``
- :samp:`{x}`. You can assume :samp:`SYMBOL_REF_HAS_BLOCK_INFO_P ({x})` and
- :samp:`!SYMBOL_REF_ANCHOR_P ({x})`.
-
- The default version is correct for most targets, but you might need to
- intercept this hook to handle things like target-specific attributes
- or target-specific sections.
-
-[TARGET_USE_ANCHORS_FOR_SYMBOL_P]
-
-[TARGET_HAS_IFUNC_P]
-.. function:: bool TARGET_HAS_IFUNC_P (void)
-
- It returns true if the target supports GNU indirect functions.
- The support includes the assembler, linker and dynamic linker.
- The default value of this hook is based on target's libc.
-
-[TARGET_HAS_IFUNC_P]
-
-[TARGET_IFUNC_REF_LOCAL_OK]
-.. function:: bool TARGET_IFUNC_REF_LOCAL_OK (void)
-
- Return true if it is OK to reference indirect function resolvers
- locally. The default is to return false.
-
-[TARGET_IFUNC_REF_LOCAL_OK]
-
-[TARGET_FUNCTION_OK_FOR_SIBCALL]
-.. function:: bool TARGET_FUNCTION_OK_FOR_SIBCALL (tree decl, tree exp)
-
- True if it is OK to do sibling call optimization for the specified
- call expression :samp:`{exp}`. :samp:`{decl}` will be the called function,
- or ``NULL`` if this is an indirect call.
-
- It is not uncommon for limitations of calling conventions to prevent
- tail calls to functions outside the current unit of translation, or
- during PIC compilation. The hook is used to enforce these restrictions,
- as the ``sibcall`` md pattern cannot fail, or fall over to a
- 'normal' call. The criteria for successful sibling call optimization
- may vary greatly between different architectures.
-
-[TARGET_FUNCTION_OK_FOR_SIBCALL]
-
-[TARGET_SET_CURRENT_FUNCTION]
-.. function:: void TARGET_SET_CURRENT_FUNCTION (tree decl)
-
- The compiler invokes this hook whenever it changes its current function
- context (``cfun``). You can define this function if
- the back end needs to perform any initialization or reset actions on a
- per-function basis. For example, it may be used to implement function
- attributes that affect register usage or code generation patterns.
- The argument :samp:`{decl}` is the declaration for the new function context,
- and may be null to indicate that the compiler has left a function context
- and is returning to processing at the top level.
- The default hook function does nothing.
-
- GCC sets ``cfun`` to a dummy function context during initialization of
- some parts of the back end. The hook function is not invoked in this
- situation; you need not worry about the hook being invoked recursively,
- or when the back end is in a partially-initialized state.
- ``cfun`` might be ``NULL`` to indicate processing at top level,
- outside of any function scope.
-
-[TARGET_SET_CURRENT_FUNCTION]
-
-[TARGET_IN_SMALL_DATA_P]
-.. function:: bool TARGET_IN_SMALL_DATA_P (const_tree exp)
-
- Returns true if :samp:`{exp}` should be placed into a 'small data' section.
- The default version of this hook always returns false.
-
-[TARGET_IN_SMALL_DATA_P]
-
-[TARGET_BINDS_LOCAL_P]
-.. function:: bool TARGET_BINDS_LOCAL_P (const_tree exp)
-
- Returns true if :samp:`{exp}` names an object for which name resolution
- rules must resolve to the current 'module' (dynamic shared library
- or executable image).
-
- The default version of this hook implements the name resolution rules
- for ELF, which has a looser model of global name binding than other
- currently supported object file formats.
-
-[TARGET_BINDS_LOCAL_P]
-
-[TARGET_PROFILE_BEFORE_PROLOGUE]
-.. function:: bool TARGET_PROFILE_BEFORE_PROLOGUE (void)
-
- It returns true if target wants profile code emitted before prologue.
-
- The default version of this hook use the target macro
- ``PROFILE_BEFORE_PROLOGUE``.
-
-[TARGET_PROFILE_BEFORE_PROLOGUE]
-
-[TARGET_KEEP_LEAF_WHEN_PROFILED]
-.. function:: bool TARGET_KEEP_LEAF_WHEN_PROFILED (void)
-
- This target hook returns true if the target wants the leaf flag for
- the current function to stay true even if it calls mcount. This might
- make sense for targets using the leaf flag only to determine whether a
- stack frame needs to be generated or not and for which the call to
- mcount is generated before the function prologue.
-
-[TARGET_KEEP_LEAF_WHEN_PROFILED]
-
-[TARGET_MANGLE_DECL_ASSEMBLER_NAME]
-.. function:: tree TARGET_MANGLE_DECL_ASSEMBLER_NAME (tree decl, tree id)
-
- Define this hook if you need to postprocess the assembler name generated
- by target-independent code. The :samp:`{id}` provided to this hook will be
- the computed name (e.g., the macro ``DECL_NAME`` of the :samp:`{decl}` in C,
- or the mangled name of the :samp:`{decl}` in C++). The return value of the
- hook is an ``IDENTIFIER_NODE`` for the appropriate mangled name on
- your target system. The default implementation of this hook just
- returns the :samp:`{id}` provided.
-
-[TARGET_MANGLE_DECL_ASSEMBLER_NAME]
-
-[TARGET_ENCODE_SECTION_INFO]
-.. function:: void TARGET_ENCODE_SECTION_INFO (tree decl, rtx rtl, int new_decl_p)
-
- Define this hook if references to a symbol or a constant must be
- treated differently depending on something about the variable or
- function named by the symbol (such as what section it is in).
-
- The hook is executed immediately after rtl has been created for
- :samp:`{decl}`, which may be a variable or function declaration or
- an entry in the constant pool. In either case, :samp:`{rtl}` is the
- rtl in question. Do *not* use ``DECL_RTL (decl)``
- in this hook; that field may not have been initialized yet.
-
- In the case of a constant, it is safe to assume that the rtl is
- a ``mem`` whose address is a ``symbol_ref``. Most decls
- will also have this form, but that is not guaranteed. Global
- register variables, for instance, will have a ``reg`` for their
- rtl. (Normally the right thing to do with such unusual rtl is
- leave it alone.)
-
- The :samp:`{new_decl_p}` argument will be true if this is the first time
- that ``TARGET_ENCODE_SECTION_INFO`` has been invoked on this decl. It will
- be false for subsequent invocations, which will happen for duplicate
- declarations. Whether or not anything must be done for the duplicate
- declaration depends on whether the hook examines ``DECL_ATTRIBUTES``.
- :samp:`{new_decl_p}` is always true when the hook is called for a constant.
-
- .. index:: SYMBOL_REF_FLAG, in TARGET_ENCODE_SECTION_INFO
-
- The usual thing for this hook to do is to record flags in the
- ``symbol_ref``, using ``SYMBOL_REF_FLAG`` or ``SYMBOL_REF_FLAGS``.
- Historically, the name string was modified if it was necessary to
- encode more than one bit of information, but this practice is now
- discouraged; use ``SYMBOL_REF_FLAGS``.
-
- The default definition of this hook, ``default_encode_section_info``
- in :samp:`varasm.cc`, sets a number of commonly-useful bits in
- ``SYMBOL_REF_FLAGS``. Check whether the default does what you need
- before overriding it.
-
-[TARGET_ENCODE_SECTION_INFO]
-
-[TARGET_STRIP_NAME_ENCODING]
-.. function:: const char * TARGET_STRIP_NAME_ENCODING (const char *name)
-
- Decode :samp:`{name}` and return the real name part, sans
- the characters that ``TARGET_ENCODE_SECTION_INFO``
- may have added.
-
-[TARGET_STRIP_NAME_ENCODING]
-
-[TARGET_SHIFT_TRUNCATION_MASK]
-.. function:: unsigned HOST_WIDE_INT TARGET_SHIFT_TRUNCATION_MASK (machine_mode mode)
-
- This function describes how the standard shift patterns for :samp:`{mode}`
- deal with shifts by negative amounts or by more than the width of the mode.
- See :ref:`shift-patterns`.
-
- On many machines, the shift patterns will apply a mask :samp:`{m}` to the
- shift count, meaning that a fixed-width shift of :samp:`{x}` by :samp:`{y}` is
- equivalent to an arbitrary-width shift of :samp:`{x}` by :samp:`{y & m}`. If
- this is true for mode :samp:`{mode}`, the function should return :samp:`{m}`,
- otherwise it should return 0. A return value of 0 indicates that no
- particular behavior is guaranteed.
-
- Note that, unlike ``SHIFT_COUNT_TRUNCATED``, this function does
- *not* apply to general shift rtxes; it applies only to instructions
- that are generated by the named shift patterns.
-
- The default implementation of this function returns
- ``GET_MODE_BITSIZE (mode) - 1`` if ``SHIFT_COUNT_TRUNCATED``
- and 0 otherwise. This definition is always safe, but if
- ``SHIFT_COUNT_TRUNCATED`` is false, and some shift patterns
- nevertheless truncate the shift count, you may get better code
- by overriding it.
-
-[TARGET_SHIFT_TRUNCATION_MASK]
-
-[TARGET_MIN_DIVISIONS_FOR_RECIP_MUL]
-.. function:: unsigned int TARGET_MIN_DIVISIONS_FOR_RECIP_MUL (machine_mode mode)
-
- When :option:`-ffast-math` is in effect, GCC tries to optimize
- divisions by the same divisor, by turning them into multiplications by
- the reciprocal. This target hook specifies the minimum number of divisions
- that should be there for GCC to perform the optimization for a variable
- of mode :samp:`{mode}`. The default implementation returns 3 if the machine
- has an instruction for the division, and 2 if it does not.
-
-[TARGET_MIN_DIVISIONS_FOR_RECIP_MUL]
-
-[TARGET_TRULY_NOOP_TRUNCATION]
-.. function:: bool TARGET_TRULY_NOOP_TRUNCATION (poly_uint64 outprec, poly_uint64 inprec)
-
- This hook returns true if it is safe to 'convert' a value of
- :samp:`{inprec}` bits to one of :samp:`{outprec}` bits (where :samp:`{outprec}` is
- smaller than :samp:`{inprec}`) by merely operating on it as if it had only
- :samp:`{outprec}` bits. The default returns true unconditionally, which
- is correct for most machines. When ``TARGET_TRULY_NOOP_TRUNCATION``
- returns false, the machine description should provide a ``trunc``
- optab to specify the RTL that performs the required truncation.
-
- If ``TARGET_MODES_TIEABLE_P`` returns false for a pair of modes,
- suboptimal code can result if this hook returns true for the corresponding
- mode sizes. Making this hook return false in such cases may improve things.
-
-[TARGET_TRULY_NOOP_TRUNCATION]
-
-[TARGET_MODE_REP_EXTENDED]
-.. function:: int TARGET_MODE_REP_EXTENDED (scalar_int_mode mode, scalar_int_mode rep_mode)
-
- The representation of an integral mode can be such that the values
- are always extended to a wider integral mode. Return
- ``SIGN_EXTEND`` if values of :samp:`{mode}` are represented in
- sign-extended form to :samp:`{rep_mode}`. Return ``UNKNOWN``
- otherwise. (Currently, none of the targets use zero-extended
- representation this way so unlike ``LOAD_EXTEND_OP``,
- ``TARGET_MODE_REP_EXTENDED`` is expected to return either
- ``SIGN_EXTEND`` or ``UNKNOWN``. Also no target extends
- :samp:`{mode}` to :samp:`{rep_mode}` so that :samp:`{rep_mode}` is not the next
- widest integral mode and currently we take advantage of this fact.)
-
- Similarly to ``LOAD_EXTEND_OP`` you may return a non- ``UNKNOWN``
- value even if the extension is not performed on certain hard registers
- as long as for the ``REGNO_REG_CLASS`` of these hard registers
- ``TARGET_CAN_CHANGE_MODE_CLASS`` returns false.
-
- Note that ``TARGET_MODE_REP_EXTENDED`` and ``LOAD_EXTEND_OP``
- describe two related properties. If you define
- ``TARGET_MODE_REP_EXTENDED (mode, word_mode)`` you probably also want
- to define ``LOAD_EXTEND_OP (mode)`` to return the same type of
- extension.
-
- In order to enforce the representation of ``mode``,
- ``TARGET_TRULY_NOOP_TRUNCATION`` should return false when truncating to
- ``mode``.
-
-[TARGET_MODE_REP_EXTENDED]
-
-[TARGET_SETJMP_PRESERVES_NONVOLATILE_REGS_P]
-.. function:: bool TARGET_SETJMP_PRESERVES_NONVOLATILE_REGS_P (void)
-
- On some targets, it is assumed that the compiler will spill all pseudos
- that are live across a call to ``setjmp``, while other targets treat
- ``setjmp`` calls as normal function calls.
-
- This hook returns false if ``setjmp`` calls do not preserve all
- non-volatile registers so that gcc that must spill all pseudos that are
- live across ``setjmp`` calls. Define this to return true if the
- target does not need to spill all pseudos live across ``setjmp`` calls.
- The default implementation conservatively assumes all pseudos must be
- spilled across ``setjmp`` calls.
-
-[TARGET_SETJMP_PRESERVES_NONVOLATILE_REGS_P]
-
-[TARGET_VALID_POINTER_MODE]
-.. function:: bool TARGET_VALID_POINTER_MODE (scalar_int_mode mode)
-
- Define this to return nonzero if the port can handle pointers
- with machine mode :samp:`{mode}`. The default version of this
- hook returns true for both ``ptr_mode`` and ``Pmode``.
-
-[TARGET_VALID_POINTER_MODE]
-
-[TARGET_REF_MAY_ALIAS_ERRNO]
-.. function:: bool TARGET_REF_MAY_ALIAS_ERRNO (ao_ref *ref)
-
- Define this to return nonzero if the memory reference :samp:`{ref}`
- may alias with the system C library errno location. The default
- version of this hook assumes the system C library errno location
- is either a declaration of type int or accessed by dereferencing
- a pointer to int.
-
-[TARGET_REF_MAY_ALIAS_ERRNO]
-
-[TARGET_ADDR_SPACE_POINTER_MODE]
-.. function:: scalar_int_mode TARGET_ADDR_SPACE_POINTER_MODE (addr_space_t address_space)
-
- Define this to return the machine mode to use for pointers to
- :samp:`{address_space}` if the target supports named address spaces.
- The default version of this hook returns ``ptr_mode``.
-
-[TARGET_ADDR_SPACE_POINTER_MODE]
-
-[TARGET_ADDR_SPACE_ADDRESS_MODE]
-.. function:: scalar_int_mode TARGET_ADDR_SPACE_ADDRESS_MODE (addr_space_t address_space)
-
- Define this to return the machine mode to use for addresses in
- :samp:`{address_space}` if the target supports named address spaces.
- The default version of this hook returns ``Pmode``.
-
-[TARGET_ADDR_SPACE_ADDRESS_MODE]
-
-[TARGET_ADDR_SPACE_VALID_POINTER_MODE]
-.. function:: bool TARGET_ADDR_SPACE_VALID_POINTER_MODE (scalar_int_mode mode, addr_space_t as)
-
- Define this to return nonzero if the port can handle pointers
- with machine mode :samp:`{mode}` to address space :samp:`{as}`. This target
- hook is the same as the ``TARGET_VALID_POINTER_MODE`` target hook,
- except that it includes explicit named address space support. The default
- version of this hook returns true for the modes returned by either the
- ``TARGET_ADDR_SPACE_POINTER_MODE`` or ``TARGET_ADDR_SPACE_ADDRESS_MODE``
- target hooks for the given address space.
-
-[TARGET_ADDR_SPACE_VALID_POINTER_MODE]
-
-[TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P]
-.. function:: bool TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P (machine_mode mode, rtx exp, bool strict, addr_space_t as)
-
- Define this to return true if :samp:`{exp}` is a valid address for mode
- :samp:`{mode}` in the named address space :samp:`{as}`. The :samp:`{strict}`
- parameter says whether strict addressing is in effect after reload has
- finished. This target hook is the same as the
- ``TARGET_LEGITIMATE_ADDRESS_P`` target hook, except that it includes
- explicit named address space support.
-
-[TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P]
-
-[TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS]
-.. function:: rtx TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS (rtx x, rtx oldx, machine_mode mode, addr_space_t as)
-
- Define this to modify an invalid address :samp:`{x}` to be a valid address
- with mode :samp:`{mode}` in the named address space :samp:`{as}`. This target
- hook is the same as the ``TARGET_LEGITIMIZE_ADDRESS`` target hook,
- except that it includes explicit named address space support.
-
-[TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS]
-
-[TARGET_ADDR_SPACE_SUBSET_P]
-.. function:: bool TARGET_ADDR_SPACE_SUBSET_P (addr_space_t subset, addr_space_t superset)
-
- Define this to return whether the :samp:`{subset}` named address space is
- contained within the :samp:`{superset}` named address space. Pointers to
- a named address space that is a subset of another named address space
- will be converted automatically without a cast if used together in
- arithmetic operations. Pointers to a superset address space can be
- converted to pointers to a subset address space via explicit casts.
-
-[TARGET_ADDR_SPACE_SUBSET_P]
-
-[TARGET_ADDR_SPACE_ZERO_ADDRESS_VALID]
-.. function:: bool TARGET_ADDR_SPACE_ZERO_ADDRESS_VALID (addr_space_t as)
-
- Define this to modify the default handling of address 0 for the
- address space. Return true if 0 should be considered a valid address.
-
-[TARGET_ADDR_SPACE_ZERO_ADDRESS_VALID]
-
-[TARGET_ADDR_SPACE_CONVERT]
-.. function:: rtx TARGET_ADDR_SPACE_CONVERT (rtx op, tree from_type, tree to_type)
-
- Define this to convert the pointer expression represented by the RTL
- :samp:`{op}` with type :samp:`{from_type}` that points to a named address
- space to a new pointer expression with type :samp:`{to_type}` that points
- to a different named address space. When this hook it called, it is
- guaranteed that one of the two address spaces is a subset of the other,
- as determined by the ``TARGET_ADDR_SPACE_SUBSET_P`` target hook.
-
-[TARGET_ADDR_SPACE_CONVERT]
-
-[TARGET_ADDR_SPACE_DEBUG]
-.. function:: int TARGET_ADDR_SPACE_DEBUG (addr_space_t as)
-
- Define this to define how the address space is encoded in dwarf.
- The result is the value to be used with ``DW_AT_address_class``.
-
-[TARGET_ADDR_SPACE_DEBUG]
-
-[TARGET_ADDR_SPACE_DIAGNOSE_USAGE]
-.. function:: void TARGET_ADDR_SPACE_DIAGNOSE_USAGE (addr_space_t as, location_t loc)
-
- Define this hook if the availability of an address space depends on
- command line options and some diagnostics should be printed when the
- address space is used. This hook is called during parsing and allows
- to emit a better diagnostic compared to the case where the address space
- was not registered with ``c_register_addr_space``. :samp:`{as}` is
- the address space as registered with ``c_register_addr_space``.
- :samp:`{loc}` is the location of the address space qualifier token.
- The default implementation does nothing.
-
-[TARGET_ADDR_SPACE_DIAGNOSE_USAGE]
-
-[TARGET_LOWER_LOCAL_DECL_ALIGNMENT]
-.. function:: void TARGET_LOWER_LOCAL_DECL_ALIGNMENT (tree decl)
-
- Define this hook to lower alignment of local, parm or result
- decl :samp:`({decl})`.
-
-[TARGET_LOWER_LOCAL_DECL_ALIGNMENT]
-
-[TARGET_STATIC_RTX_ALIGNMENT]
-.. function:: HOST_WIDE_INT TARGET_STATIC_RTX_ALIGNMENT (machine_mode mode)
-
- This hook returns the preferred alignment in bits for a
- statically-allocated rtx, such as a constant pool entry. :samp:`{mode}`
- is the mode of the rtx. The default implementation returns
- :samp:`GET_MODE_ALIGNMENT ({mode})`.
-
-[TARGET_STATIC_RTX_ALIGNMENT]
-
-[TARGET_CONSTANT_ALIGNMENT]
-.. function:: HOST_WIDE_INT TARGET_CONSTANT_ALIGNMENT (const_tree constant, HOST_WIDE_INT basic_align)
-
- This hook returns the alignment in bits of a constant that is being
- placed in memory. :samp:`{constant}` is the constant and :samp:`{basic_align}`
- is the alignment that the object would ordinarily have.
-
- The default definition just returns :samp:`{basic_align}`.
-
- The typical use of this hook is to increase alignment for string
- constants to be word aligned so that ``strcpy`` calls that copy
- constants can be done inline. The function
- ``constant_alignment_word_strings`` provides such a definition.
-
-[TARGET_CONSTANT_ALIGNMENT]
-
-[TARGET_TRANSLATE_MODE_ATTRIBUTE]
-.. function:: machine_mode TARGET_TRANSLATE_MODE_ATTRIBUTE (machine_mode mode)
-
- Define this hook if during mode attribute processing, the port should
- translate machine_mode :samp:`{mode}` to another mode. For example, rs6000's
- ``KFmode``, when it is the same as ``TFmode``.
-
- The default version of the hook returns that mode that was passed in.
-
-[TARGET_TRANSLATE_MODE_ATTRIBUTE]
-
-[TARGET_SCALAR_MODE_SUPPORTED_P]
-.. function:: bool TARGET_SCALAR_MODE_SUPPORTED_P (scalar_mode mode)
-
- Define this to return nonzero if the port is prepared to handle
- insns involving scalar mode :samp:`{mode}`. For a scalar mode to be
- considered supported, all the basic arithmetic and comparisons
- must work.
-
- The default version of this hook returns true for any mode
- required to handle the basic C types (as defined by the port).
- Included here are the double-word arithmetic supported by the
- code in :samp:`optabs.cc`.
-
-[TARGET_SCALAR_MODE_SUPPORTED_P]
-
-[TARGET_VECTOR_MODE_SUPPORTED_P]
-.. function:: bool TARGET_VECTOR_MODE_SUPPORTED_P (machine_mode mode)
-
- Define this to return nonzero if the port is prepared to handle
- insns involving vector mode :samp:`{mode}`. At the very least, it
- must have move patterns for this mode.
-
-[TARGET_VECTOR_MODE_SUPPORTED_P]
-
-[TARGET_COMPATIBLE_VECTOR_TYPES_P]
-.. function:: bool TARGET_COMPATIBLE_VECTOR_TYPES_P (const_tree type1, const_tree type2)
-
- Return true if there is no target-specific reason for treating
- vector types :samp:`{type1}` and :samp:`{type2}` as distinct types. The caller
- has already checked for target-independent reasons, meaning that the
- types are known to have the same mode, to have the same number of elements,
- and to have what the caller considers to be compatible element types.
-
- The main reason for defining this hook is to reject pairs of types
- that are handled differently by the target's calling convention.
- For example, when a new :samp:`{N}` -bit vector architecture is added
- to a target, the target may want to handle normal :samp:`{N}` -bit
- ``VECTOR_TYPE`` arguments and return values in the same way as
- before, to maintain backwards compatibility. However, it may also
- provide new, architecture-specific ``VECTOR_TYPE`` s that are passed
- and returned in a more efficient way. It is then important to maintain
- a distinction between the 'normal' ``VECTOR_TYPE`` s and the new
- architecture-specific ones.
-
- The default implementation returns true, which is correct for most targets.
-
-[TARGET_COMPATIBLE_VECTOR_TYPES_P]
-
-[TARGET_VECTOR_ALIGNMENT]
-.. function:: HOST_WIDE_INT TARGET_VECTOR_ALIGNMENT (const_tree type)
-
- This hook can be used to define the alignment for a vector of type
- :samp:`{type}`, in order to comply with a platform ABI. The default is to
- require natural alignment for vector types. The alignment returned by
- this hook must be a power-of-two multiple of the default alignment of
- the vector element type.
-
-[TARGET_VECTOR_ALIGNMENT]
-
-[TARGET_ARRAY_MODE]
-.. function:: opt_machine_mode TARGET_ARRAY_MODE (machine_mode mode, unsigned HOST_WIDE_INT nelems)
-
- Return the mode that GCC should use for an array that has
- :samp:`{nelems}` elements, with each element having mode :samp:`{mode}`.
- Return no mode if the target has no special requirements. In the
- latter case, GCC looks for an integer mode of the appropriate size
- if available and uses BLKmode otherwise. Usually the search for the
- integer mode is limited to ``MAX_FIXED_MODE_SIZE``, but the
- ``TARGET_ARRAY_MODE_SUPPORTED_P`` hook allows a larger mode to be
- used in specific cases.
-
- The main use of this hook is to specify that an array of vectors should
- also have a vector mode. The default implementation returns no mode.
-
-[TARGET_ARRAY_MODE]
-
-[TARGET_ARRAY_MODE_SUPPORTED_P]
-.. function:: bool TARGET_ARRAY_MODE_SUPPORTED_P (machine_mode mode, unsigned HOST_WIDE_INT nelems)
-
- Return true if GCC should try to use a scalar mode to store an array
- of :samp:`{nelems}` elements, given that each element has mode :samp:`{mode}`.
- Returning true here overrides the usual ``MAX_FIXED_MODE`` limit
- and allows GCC to use any defined integer mode.
-
- One use of this hook is to support vector load and store operations
- that operate on several homogeneous vectors. For example, ARM NEON
- has operations like:
-
- .. code-block:: c++
-
- int8x8x3_t vld3_s8 (const int8_t *)
-
- where the return type is defined as:
-
- .. code-block:: c++
-
- typedef struct int8x8x3_t
- {
- int8x8_t val[3];
- } int8x8x3_t;
-
- If this hook allows ``val`` to have a scalar mode, then
- ``int8x8x3_t`` can have the same mode. GCC can then store
- ``int8x8x3_t`` s in registers rather than forcing them onto the stack.
-
-[TARGET_ARRAY_MODE_SUPPORTED_P]
-
-[TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P]
-.. function:: bool TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P (scalar_float_mode mode)
-
- Define this to return nonzero if libgcc provides support for the
- floating-point mode :samp:`{mode}`, which is known to pass
- ``TARGET_SCALAR_MODE_SUPPORTED_P``. The default version of this
- hook returns true for all of ``SFmode``, ``DFmode``,
- ``XFmode`` and ``TFmode``, if such modes exist.
-
-[TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P]
-
-[TARGET_FLOATN_MODE]
-.. function:: opt_scalar_float_mode TARGET_FLOATN_MODE (int n, bool extended)
-
- Define this to return the machine mode to use for the type
- ``_Floatn``, if :samp:`{extended}` is false, or the type
- ``_Floatnx``, if :samp:`{extended}` is true. If such a type is not
- supported, return ``opt_scalar_float_mode ()``. The default version of
- this hook returns ``SFmode`` for ``_Float32``, ``DFmode`` for
- ``_Float64`` and ``_Float32x`` and ``TFmode`` for
- ``_Float128``, if those modes exist and satisfy the requirements for
- those types and pass ``TARGET_SCALAR_MODE_SUPPORTED_P`` and
- ``TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P`` ; for ``_Float64x``, it
- returns the first of ``XFmode`` and ``TFmode`` that exists and
- satisfies the same requirements; for other types, it returns
- ``opt_scalar_float_mode ()``. The hook is only called for values
- of :samp:`{n}` and :samp:`{extended}` that are valid according to
- ISO/IEC TS 18661-3:2015; that is, :samp:`{n}` is one of 32, 64, 128, or,
- if :samp:`{extended}` is false, 16 or greater than 128 and a multiple of 32.
-
-[TARGET_FLOATN_MODE]
-
-[TARGET_FLOATN_BUILTIN_P]
-.. function:: bool TARGET_FLOATN_BUILTIN_P (int func)
-
- 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. In strict ANSI/ISO mode, the built-in function without
- the ``__builtin_`` prefix is not enabled. The argument ``FUNC`` is the
- ``enum built_in_function`` id of the function to be enabled.
-
-[TARGET_FLOATN_BUILTIN_P]
-
-[TARGET_REGISTER_MOVE_COST]
-.. function:: int TARGET_REGISTER_MOVE_COST (machine_mode mode, reg_class_t from, reg_class_t to)
-
- This target hook should return the cost of moving data of mode :samp:`{mode}`
- from a register in class :samp:`{from}` to one in class :samp:`{to}`. The classes
- are expressed using the enumeration values such as ``GENERAL_REGS``.
- A value of 2 is the default; other values are interpreted relative to
- that.
-
- It is not required that the cost always equal 2 when :samp:`{from}` is the
- same as :samp:`{to}` ; on some machines it is expensive to move between
- registers if they are not general registers.
-
- If reload sees an insn consisting of a single ``set`` between two
- hard registers, and if ``TARGET_REGISTER_MOVE_COST`` applied to their
- classes returns a value of 2, reload does not check to ensure that the
- constraints of the insn are met. Setting a cost of other than 2 will
- allow reload to verify that the constraints are met. You should do this
- if the :samp:`mov{m}` pattern's constraints do not allow such copying.
-
- The default version of this function returns 2.
-
-[TARGET_REGISTER_MOVE_COST]
-
-[TARGET_MEMORY_MOVE_COST]
-.. function:: int TARGET_MEMORY_MOVE_COST (machine_mode mode, reg_class_t rclass, bool in)
-
- This target hook should return the cost of moving data of mode :samp:`{mode}`
- between a register of class :samp:`{rclass}` and memory; :samp:`{in}` is ``false``
- if the value is to be written to memory, ``true`` if it is to be read in.
- This cost is relative to those in ``TARGET_REGISTER_MOVE_COST``.
- If moving between registers and memory is more expensive than between two
- registers, you should add this target hook to express the relative cost.
-
- If you do not add this target hook, GCC uses a default cost of 4 plus
- the cost of copying via a secondary reload register, if one is
- needed. If your machine requires a secondary reload register to copy
- between memory and a register of :samp:`{rclass}` but the reload mechanism is
- more complex than copying via an intermediate, use this target hook to
- reflect the actual cost of the move.
-
- GCC defines the function ``memory_move_secondary_cost`` if
- secondary reloads are needed. It computes the costs due to copying via
- a secondary register. If your machine copies from memory using a
- secondary register in the conventional way but the default base value of
- 4 is not correct for your machine, use this target hook to add some other
- value to the result of that function. The arguments to that function
- are the same as to this target hook.
-
-[TARGET_MEMORY_MOVE_COST]
-
-[TARGET_USE_BY_PIECES_INFRASTRUCTURE_P]
-.. function:: bool TARGET_USE_BY_PIECES_INFRASTRUCTURE_P (unsigned HOST_WIDE_INT size, unsigned int alignment, enum by_pieces_operation op, bool speed_p)
-
- GCC will attempt several strategies when asked to copy between
- two areas of memory, or to set, clear or store to memory, for example
- when copying a ``struct``. The ``by_pieces`` infrastructure
- implements such memory operations as a sequence of load, store or move
- insns. Alternate strategies are to expand the
- ``cpymem`` or ``setmem`` optabs, to emit a library call, or to emit
- unit-by-unit, loop-based operations.
-
- This target hook should return true if, for a memory operation with a
- given :samp:`{size}` and :samp:`{alignment}`, using the ``by_pieces``
- infrastructure is expected to result in better code generation.
- Both :samp:`{size}` and :samp:`{alignment}` are measured in terms of storage
- units.
-
- The parameter :samp:`{op}` is one of: ``CLEAR_BY_PIECES``,
- ``MOVE_BY_PIECES``, ``SET_BY_PIECES``, ``STORE_BY_PIECES`` or
- ``COMPARE_BY_PIECES``. These describe the type of memory operation
- under consideration.
-
- The parameter :samp:`{speed_p}` is true if the code is currently being
- optimized for speed rather than size.
-
- Returning true for higher values of :samp:`{size}` can improve code generation
- for speed if the target does not provide an implementation of the
- ``cpymem`` or ``setmem`` standard names, if the ``cpymem`` or
- ``setmem`` implementation would be more expensive than a sequence of
- insns, or if the overhead of a library call would dominate that of
- the body of the memory operation.
-
- Returning true for higher values of ``size`` may also cause an increase
- in code size, for example where the number of insns emitted to perform a
- move would be greater than that of a library call.
-
-[TARGET_USE_BY_PIECES_INFRASTRUCTURE_P]
-
-[TARGET_OVERLAP_OP_BY_PIECES_P]
-.. function:: bool TARGET_OVERLAP_OP_BY_PIECES_P (void)
-
- This target hook should return true if when the ``by_pieces``
- infrastructure is used, an offset adjusted unaligned memory operation
- in the smallest integer mode for the last piece operation of a memory
- region can be generated to avoid doing more than one smaller operations.
-
-[TARGET_OVERLAP_OP_BY_PIECES_P]
-
-[TARGET_COMPARE_BY_PIECES_BRANCH_RATIO]
-.. function:: int TARGET_COMPARE_BY_PIECES_BRANCH_RATIO (machine_mode mode)
-
- When expanding a block comparison in MODE, gcc can try to reduce the
- number of branches at the expense of more memory operations. This hook
- allows the target to override the default choice. It should return the
- factor by which branches should be reduced over the plain expansion with
- one comparison per :samp:`{mode}` -sized piece. A port can also prevent a
- particular mode from being used for block comparisons by returning a
- negative number from this hook.
-
-[TARGET_COMPARE_BY_PIECES_BRANCH_RATIO]
-
-[TARGET_SLOW_UNALIGNED_ACCESS]
-.. function:: bool TARGET_SLOW_UNALIGNED_ACCESS (machine_mode mode, unsigned int align)
-
- This hook returns true if memory accesses described by the
- :samp:`{mode}` and :samp:`{alignment}` parameters have a cost many times greater
- than aligned accesses, for example if they are emulated in a trap handler.
- This hook is invoked only for unaligned accesses, i.e. when
- ``alignment < GET_MODE_ALIGNMENT (mode)``.
-
- When this hook returns true, the compiler will act as if
- ``STRICT_ALIGNMENT`` were true when generating code for block
- moves. This can cause significantly more instructions to be produced.
- Therefore, do not make this hook return true if unaligned accesses only
- add a cycle or two to the time for a memory access.
-
- The hook must return true whenever ``STRICT_ALIGNMENT`` is true.
- The default implementation returns ``STRICT_ALIGNMENT``.
-
-[TARGET_SLOW_UNALIGNED_ACCESS]
-
-[TARGET_OPTAB_SUPPORTED_P]
-.. function:: bool TARGET_OPTAB_SUPPORTED_P (int op, machine_mode mode1, machine_mode mode2, optimization_type opt_type)
-
- Return true if the optimizers should use optab :samp:`{op}` with
- modes :samp:`{mode1}` and :samp:`{mode2}` for optimization type :samp:`{opt_type}`.
- The optab is known to have an associated :samp:`.md` instruction
- whose C condition is true. :samp:`{mode2}` is only meaningful for conversion
- optabs; for direct optabs it is a copy of :samp:`{mode1}`.
-
- For example, when called with :samp:`{op}` equal to ``rint_optab`` and
- :samp:`{mode1}` equal to ``DFmode``, the hook should say whether the
- optimizers should use optab ``rintdf2``.
-
- The default hook returns true for all inputs.
-
-[TARGET_OPTAB_SUPPORTED_P]
-
-[TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P]
-.. function:: bool TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P (machine_mode mode)
-
- Define this to return nonzero for machine modes for which the port has
- small register classes. If this target hook returns nonzero for a given
- :samp:`{mode}`, the compiler will try to minimize the lifetime of registers
- in :samp:`{mode}`. The hook may be called with ``VOIDmode`` as argument.
- In this case, the hook is expected to return nonzero if it returns nonzero
- for any mode.
-
- On some machines, it is risky to let hard registers live across arbitrary
- insns. Typically, these machines have instructions that require values
- to be in specific registers (like an accumulator), and reload will fail
- if the required hard register is used for another purpose across such an
- insn.
-
- Passes before reload do not know which hard registers will be used
- in an instruction, but the machine modes of the registers set or used in
- the instruction are already known. And for some machines, register
- classes are small for, say, integer registers but not for floating point
- registers. For example, the AMD x86-64 architecture requires specific
- registers for the legacy x86 integer instructions, but there are many
- SSE registers for floating point operations. On such targets, a good
- strategy may be to return nonzero from this hook for ``INTEGRAL_MODE_P``
- machine modes but zero for the SSE register classes.
-
- The default version of this hook returns false for any mode. It is always
- safe to redefine this hook to return with a nonzero value. But if you
- unnecessarily define it, you will reduce the amount of optimizations
- that can be performed in some cases. If you do not define this hook
- to return a nonzero value when it is required, the compiler will run out
- of spill registers and print a fatal error message.
-
-[TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P]
-
-[TARGET_FLAGS_REGNUM]
-.. c:var:: unsigned int TARGET_FLAGS_REGNUM
-
- If the target has a dedicated flags register, and it needs to use the
- post-reload comparison elimination pass, or the delay slot filler pass,
- then this value should be set appropriately.
-
-[TARGET_FLAGS_REGNUM]
-
-[TARGET_RTX_COSTS]
-.. function:: bool TARGET_RTX_COSTS (rtx x, machine_mode mode, int outer_code, int opno, int *total, bool speed)
-
- This target hook describes the relative costs of RTL expressions.
-
- The cost may depend on the precise form of the expression, which is
- available for examination in :samp:`{x}`, and the fact that :samp:`{x}` appears
- as operand :samp:`{opno}` of an expression with rtx code :samp:`{outer_code}`.
- That is, the hook can assume that there is some rtx :samp:`{y}` such
- that :samp:`GET_CODE ({y}) == {outer_code}` and such that
- either (a) :samp:`XEXP ({y}, {opno}) == {x}` or
- (b) :samp:`XVEC ({y}, {opno})` contains :samp:`{x}`.
-
- :samp:`{mode}` is :samp:`{x}` 's machine mode, or for cases like ``const_int`` that
- do not have a mode, the mode in which :samp:`{x}` is used.
-
- In implementing this hook, you can use the construct
- ``COSTS_N_INSNS (n)`` to specify a cost equal to :samp:`{n}` fast
- instructions.
-
- On entry to the hook, ``*total`` contains a default estimate
- for the cost of the expression. The hook should modify this value as
- necessary. Traditionally, the default costs are ``COSTS_N_INSNS (5)``
- for multiplications, ``COSTS_N_INSNS (7)`` for division and modulus
- operations, and ``COSTS_N_INSNS (1)`` for all other operations.
-
- When optimizing for code size, i.e. when ``speed`` is
- false, this target hook should be used to estimate the relative
- size cost of an expression, again relative to ``COSTS_N_INSNS``.
-
- The hook returns true when all subexpressions of :samp:`{x}` have been
- processed, and false when ``rtx_cost`` should recurse.
-
-[TARGET_RTX_COSTS]
-
-[TARGET_ADDRESS_COST]
-.. function:: int TARGET_ADDRESS_COST (rtx address, machine_mode mode, addr_space_t as, bool speed)
-
- This hook computes the cost of an addressing mode that contains
- :samp:`{address}`. If not defined, the cost is computed from
- the :samp:`{address}` expression and the ``TARGET_RTX_COST`` hook.
-
- For most CISC machines, the default cost is a good approximation of the
- true cost of the addressing mode. However, on RISC machines, all
- instructions normally have the same length and execution time. Hence
- all addresses will have equal costs.
-
- In cases where more than one form of an address is known, the form with
- the lowest cost will be used. If multiple forms have the same, lowest,
- cost, the one that is the most complex will be used.
-
- For example, suppose an address that is equal to the sum of a register
- and a constant is used twice in the same basic block. When this macro
- is not defined, the address will be computed in a register and memory
- references will be indirect through that register. On machines where
- the cost of the addressing mode containing the sum is no higher than
- that of a simple indirect reference, this will produce an additional
- instruction and possibly require an additional register. Proper
- specification of this macro eliminates this overhead for such machines.
-
- This hook is never called with an invalid address.
-
- On machines where an address involving more than one register is as
- cheap as an address computation involving only one register, defining
- ``TARGET_ADDRESS_COST`` to reflect this can cause two registers to
- be live over a region of code where only one would have been if
- ``TARGET_ADDRESS_COST`` were not defined in that manner. This effect
- should be considered in the definition of this macro. Equivalent costs
- should probably only be given to addresses with different numbers of
- registers on machines with lots of registers.
-
-[TARGET_ADDRESS_COST]
-
-[TARGET_INSN_COST]
-.. function:: int TARGET_INSN_COST (rtx_insn *insn, bool speed)
-
- This target hook describes the relative costs of RTL instructions.
-
- In implementing this hook, you can use the construct
- ``COSTS_N_INSNS (n)`` to specify a cost equal to :samp:`{n}` fast
- instructions.
-
- When optimizing for code size, i.e. when ``speed`` is
- false, this target hook should be used to estimate the relative
- size cost of an expression, again relative to ``COSTS_N_INSNS``.
-
-[TARGET_INSN_COST]
-
-[TARGET_MAX_NOCE_IFCVT_SEQ_COST]
-.. function:: unsigned int TARGET_MAX_NOCE_IFCVT_SEQ_COST (edge e)
-
- This hook returns a value in the same units as ``TARGET_RTX_COSTS``,
- giving the maximum acceptable cost for a sequence generated by the RTL
- if-conversion pass when conditional execution is not available.
- The RTL if-conversion pass attempts to convert conditional operations
- that would require a branch to a series of unconditional operations and
- ``movmodecc`` insns. This hook returns the maximum cost of the
- unconditional instructions and the ``movmodecc`` insns.
- RTL if-conversion is cancelled if the cost of the converted sequence
- is greater than the value returned by this hook.
-
- ``e`` is the edge between the basic block containing the conditional
- branch to the basic block which would be executed if the condition
- were true.
-
- The default implementation of this hook uses the
- ``max-rtl-if-conversion-[un]predictable`` parameters if they are set,
- and uses a multiple of ``BRANCH_COST`` otherwise.
-
-[TARGET_MAX_NOCE_IFCVT_SEQ_COST]
-
-[TARGET_NOCE_CONVERSION_PROFITABLE_P]
-.. function:: bool TARGET_NOCE_CONVERSION_PROFITABLE_P (rtx_insn *seq, struct noce_if_info *if_info)
-
- This hook returns true if the instruction sequence ``seq`` is a good
- candidate as a replacement for the if-convertible sequence described in
- ``if_info``.
-
-[TARGET_NOCE_CONVERSION_PROFITABLE_P]
-
-[TARGET_NEW_ADDRESS_PROFITABLE_P]
-.. function:: bool TARGET_NEW_ADDRESS_PROFITABLE_P (rtx memref, rtx_insn * insn, rtx new_addr)
-
- Return ``true`` if it is profitable to replace the address in
- :samp:`{memref}` with :samp:`{new_addr}`. This allows targets to prevent the
- scheduler from undoing address optimizations. The instruction containing the
- memref is :samp:`{insn}`. The default implementation returns ``true``.
-
-[TARGET_NEW_ADDRESS_PROFITABLE_P]
-
-[TARGET_ESTIMATED_POLY_VALUE]
-.. function:: HOST_WIDE_INT TARGET_ESTIMATED_POLY_VALUE (poly_int64 val, poly_value_estimate_kind kind)
-
- Return an estimate of the runtime value of :samp:`{val}`, for use in
- things like cost calculations or profiling frequencies. :samp:`{kind}` is used
- to ask for the minimum, maximum, and likely estimates of the value through
- the ``POLY_VALUE_MIN``, ``POLY_VALUE_MAX`` and
- ``POLY_VALUE_LIKELY`` values. The default
- implementation returns the lowest possible value of :samp:`{val}`.
-
-[TARGET_ESTIMATED_POLY_VALUE]
-
-[TARGET_NO_SPECULATION_IN_DELAY_SLOTS_P]
-.. function:: bool TARGET_NO_SPECULATION_IN_DELAY_SLOTS_P (void)
-
- This predicate controls the use of the eager delay slot filler to disallow
- speculatively executed instructions being placed in delay slots. Targets
- such as certain MIPS architectures possess both branches with and without
- delay slots. As the eager delay slot filler can decrease performance,
- disabling it is beneficial when ordinary branches are available. Use of
- delay slot branches filled using the basic filler is often still desirable
- as the delay slot can hide a pipeline bubble.
-
-[TARGET_NO_SPECULATION_IN_DELAY_SLOTS_P]
-
-[TARGET_ALLOCATE_INITIAL_VALUE]
-.. function:: rtx TARGET_ALLOCATE_INITIAL_VALUE (rtx hard_reg)
-
- When the initial value of a hard register has been copied in a pseudo
- register, it is often not necessary to actually allocate another register
- to this pseudo register, because the original hard register or a stack slot
- it has been saved into can be used. ``TARGET_ALLOCATE_INITIAL_VALUE``
- is called at the start of register allocation once for each hard register
- that had its initial value copied by using
- ``get_func_hard_reg_initial_val`` or ``get_hard_reg_initial_val``.
- Possible values are ``NULL_RTX``, if you don't want
- to do any special allocation, a ``REG`` rtx---that would typically be
- the hard register itself, if it is known not to be clobbered---or a
- ``MEM``.
- If you are returning a ``MEM``, this is only a hint for the allocator;
- it might decide to use another register anyways.
- You may use ``current_function_is_leaf`` or
- ``REG_N_SETS`` in the hook to determine if the hard
- register in question will not be clobbered.
- The default value of this hook is ``NULL``, which disables any special
- allocation.
-
-[TARGET_ALLOCATE_INITIAL_VALUE]
-
-[TARGET_UNSPEC_MAY_TRAP_P]
-.. function:: int TARGET_UNSPEC_MAY_TRAP_P (const_rtx x, unsigned flags)
-
- This target hook returns nonzero if :samp:`{x}`, an ``unspec`` or
- ``unspec_volatile`` operation, might cause a trap. Targets can use
- this hook to enhance precision of analysis for ``unspec`` and
- ``unspec_volatile`` operations. You may call ``may_trap_p_1``
- to analyze inner elements of :samp:`{x}` in which case :samp:`{flags}` should be
- passed along.
-
-[TARGET_UNSPEC_MAY_TRAP_P]
-
-[TARGET_DWARF_REGISTER_SPAN]
-.. function:: rtx TARGET_DWARF_REGISTER_SPAN (rtx reg)
-
- Given a register, this hook should return a parallel of registers to
- represent where to find the register pieces. Define this hook if the
- register and its mode are represented in Dwarf in non-contiguous
- locations, or if the register should be represented in more than one
- register in Dwarf. Otherwise, this hook should return ``NULL_RTX``.
- If not defined, the default is to return ``NULL_RTX``.
-
-[TARGET_DWARF_REGISTER_SPAN]
-
-[TARGET_DWARF_FRAME_REG_MODE]
-.. function:: machine_mode TARGET_DWARF_FRAME_REG_MODE (int regno)
-
- Given a register, this hook should return the mode which the
- corresponding Dwarf frame register should have. This is normally
- used to return a smaller mode than the raw mode to prevent call
- clobbered parts of a register altering the frame register size
-
-[TARGET_DWARF_FRAME_REG_MODE]
-
-[TARGET_INIT_DWARF_REG_SIZES_EXTRA]
-.. function:: void TARGET_INIT_DWARF_REG_SIZES_EXTRA (tree address)
-
- If some registers are represented in Dwarf-2 unwind information in
- multiple pieces, define this hook to fill in information about the
- sizes of those pieces in the table used by the unwinder at runtime.
- It will be called by ``expand_builtin_init_dwarf_reg_sizes`` after
- filling in a single size corresponding to each hard register;
- :samp:`{address}` is the address of the table.
-
-[TARGET_INIT_DWARF_REG_SIZES_EXTRA]
-
-[TARGET_FIXED_CONDITION_CODE_REGS]
-.. function:: bool TARGET_FIXED_CONDITION_CODE_REGS (unsigned int *p1, unsigned int *p2)
-
- On targets which use a hard
- register rather than a pseudo-register to hold condition codes, the
- regular CSE passes are often not able to identify cases in which the
- hard register is set to a common value. Use this hook to enable a
- small pass which optimizes such cases. This hook should return true
- to enable this pass, and it should set the integers to which its
- arguments point to the hard register numbers used for condition codes.
- When there is only one such register, as is true on most systems, the
- integer pointed to by :samp:`{p2}` should be set to
- ``INVALID_REGNUM``.
-
- The default version of this hook returns false.
-
-[TARGET_FIXED_CONDITION_CODE_REGS]
-
-[TARGET_CC_MODES_COMPATIBLE]
-.. function:: machine_mode TARGET_CC_MODES_COMPATIBLE (machine_mode m1, machine_mode m2)
-
- On targets which use multiple condition code modes in class
- ``MODE_CC``, it is sometimes the case that a comparison can be
- validly done in more than one mode. On such a system, define this
- target hook to take two mode arguments and to return a mode in which
- both comparisons may be validly done. If there is no such mode,
- return ``VOIDmode``.
-
- The default version of this hook checks whether the modes are the
- same. If they are, it returns that mode. If they are different, it
- returns ``VOIDmode``.
-
-[TARGET_CC_MODES_COMPATIBLE]
-
-[TARGET_MACHINE_DEPENDENT_REORG]
-.. function:: void TARGET_MACHINE_DEPENDENT_REORG (void)
-
- If non-null, this hook performs a target-specific pass over the
- instruction stream. The compiler will run it at all optimization levels,
- just before the point at which it normally does delayed-branch scheduling.
-
- The exact purpose of the hook varies from target to target. Some use
- it to do transformations that are necessary for correctness, such as
- laying out in-function constant pools or avoiding hardware hazards.
- Others use it as an opportunity to do some machine-dependent optimizations.
-
- You need not implement the hook if it has nothing to do. The default
- definition is null.
-
-[TARGET_MACHINE_DEPENDENT_REORG]
-
-[TARGET_BUILD_BUILTIN_VA_LIST]
-.. function:: tree TARGET_BUILD_BUILTIN_VA_LIST (void)
-
- This hook returns a type node for ``va_list`` for the target.
- The default version of the hook returns ``void*``.
-
-[TARGET_BUILD_BUILTIN_VA_LIST]
-
-[TARGET_ENUM_VA_LIST_P]
-.. function:: int TARGET_ENUM_VA_LIST_P (int idx, const char **pname, tree *ptree)
-
- This target hook is used in function ``c_common_nodes_and_builtins``
- to iterate through the target specific builtin types for va_list. The
- variable :samp:`{idx}` is used as iterator. :samp:`{pname}` has to be a pointer
- to a ``const char *`` and :samp:`{ptree}` a pointer to a ``tree`` typed
- variable.
- The arguments :samp:`{pname}` and :samp:`{ptree}` are used to store the result of
- this macro and are set to the name of the va_list builtin type and its
- internal type.
- If the return value of this macro is zero, then there is no more element.
- Otherwise the :samp:`{IDX}` should be increased for the next call of this
- macro to iterate through all types.
-
-[TARGET_ENUM_VA_LIST_P]
-
-[TARGET_FN_ABI_VA_LIST]
-.. function:: tree TARGET_FN_ABI_VA_LIST (tree fndecl)
-
- This hook returns the va_list type of the calling convention specified by
- :samp:`{fndecl}`.
- The default version of this hook returns ``va_list_type_node``.
-
-[TARGET_FN_ABI_VA_LIST]
-
-[TARGET_CANONICAL_VA_LIST_TYPE]
-.. function:: tree TARGET_CANONICAL_VA_LIST_TYPE (tree type)
-
- This hook returns the va_list type of the calling convention specified by the
- type of :samp:`{type}`. If :samp:`{type}` is not a valid va_list type, it returns
- ``NULL_TREE``.
-
-[TARGET_CANONICAL_VA_LIST_TYPE]
-
-[TARGET_GIMPLIFY_VA_ARG_EXPR]
-.. function:: tree TARGET_GIMPLIFY_VA_ARG_EXPR (tree valist, tree type, gimple_seq *pre_p, gimple_seq *post_p)
-
- This hook performs target-specific gimplification of
- ``VA_ARG_EXPR``. The first two parameters correspond to the
- arguments to ``va_arg`` ; the latter two are as in
- ``gimplify.cc:gimplify_expr``.
-
-[TARGET_GIMPLIFY_VA_ARG_EXPR]
-
-[TARGET_GET_PCH_VALIDITY]
-.. function:: void * TARGET_GET_PCH_VALIDITY (size_t *sz)
-
- This hook returns a pointer to the data needed by
- ``TARGET_PCH_VALID_P`` and sets
- :samp:`*{sz}` to the size of the data in bytes.
-
-[TARGET_GET_PCH_VALIDITY]
-
-[TARGET_PCH_VALID_P]
-.. function:: const char * TARGET_PCH_VALID_P (const void *data, size_t sz)
-
- This hook checks whether the options used to create a PCH file are
- compatible with the current settings. It returns ``NULL``
- if so and a suitable error message if not. Error messages will
- be presented to the user and must be localized using :samp:`_({msg})`.
-
- :samp:`{data}` is the data that was returned by ``TARGET_GET_PCH_VALIDITY``
- when the PCH file was created and :samp:`{sz}` is the size of that data in bytes.
- It's safe to assume that the data was created by the same version of the
- compiler, so no format checking is needed.
-
- The default definition of ``default_pch_valid_p`` should be
- suitable for most targets.
-
-[TARGET_PCH_VALID_P]
-
-[TARGET_PREPARE_PCH_SAVE]
-.. function:: void TARGET_PREPARE_PCH_SAVE (void)
-
- Called before writing out a PCH file. If the target has some
- garbage-collected data that needs to be in a particular state on PCH loads,
- it can use this hook to enforce that state. Very few targets need
- to do anything here.
-
-[TARGET_PREPARE_PCH_SAVE]
-
-[TARGET_CHECK_PCH_TARGET_FLAGS]
-.. function:: const char * TARGET_CHECK_PCH_TARGET_FLAGS (int pch_flags)
-
- If this hook is nonnull, the default implementation of
- ``TARGET_PCH_VALID_P`` will use it to check for compatible values
- of ``target_flags``. :samp:`{pch_flags}` specifies the value that
- ``target_flags`` had when the PCH file was created. The return
- value is the same as for ``TARGET_PCH_VALID_P``.
-
-[TARGET_CHECK_PCH_TARGET_FLAGS]
-
-[TARGET_DEFAULT_SHORT_ENUMS]
-.. function:: bool TARGET_DEFAULT_SHORT_ENUMS (void)
-
- This target hook should return true if the compiler should give an
- ``enum`` type only as many bytes as it takes to represent the range
- of possible values of that type. It should return false if all
- ``enum`` types should be allocated like ``int``.
-
- The default is to return false.
-
-[TARGET_DEFAULT_SHORT_ENUMS]
-
-[TARGET_BUILTIN_SETJMP_FRAME_VALUE]
-.. function:: rtx TARGET_BUILTIN_SETJMP_FRAME_VALUE (void)
-
- This target hook should return an rtx that is used to store
- the address of the current frame into the built in ``setjmp`` buffer.
- The default value, ``virtual_stack_vars_rtx``, is correct for most
- machines. One reason you may need to define this target hook is if
- ``hard_frame_pointer_rtx`` is the appropriate value on your machine.
-
-[TARGET_BUILTIN_SETJMP_FRAME_VALUE]
-
-[TARGET_MD_ASM_ADJUST]
-.. function:: rtx_insn * TARGET_MD_ASM_ADJUST (vec<rtx>& outputs, vec<rtx>& inputs, vec<machine_mode>& input_modes, vec<const char *>& constraints, vec<rtx>& clobbers, HARD_REG_SET& clobbered_regs, location_t loc)
-
- This target hook may add :dfn:`clobbers` to :samp:`{clobbers}` and
- :samp:`{clobbered_regs}` for any hard regs the port wishes to automatically
- clobber for an asm. The :samp:`{outputs}` and :samp:`{inputs}` may be inspected
- to avoid clobbering a register that is already used by the asm. :samp:`{loc}`
- is the source location of the asm.
-
- It may modify the :samp:`{outputs}`, :samp:`{inputs}`, :samp:`{input_modes}`, and
- :samp:`{constraints}` as necessary for other pre-processing. In this case the
- return value is a sequence of insns to emit after the asm. Note that
- changes to :samp:`{inputs}` must be accompanied by the corresponding changes
- to :samp:`{input_modes}`.
-
-[TARGET_MD_ASM_ADJUST]
-
-[TARGET_DWARF_CALLING_CONVENTION]
-.. function:: int TARGET_DWARF_CALLING_CONVENTION (const_tree function)
-
- Define this to enable the dwarf attribute ``DW_AT_calling_convention`` to
- be emitted for each function. Instead of an integer return the enum
- value for the ``DW_CC_`` tag.
-
-[TARGET_DWARF_CALLING_CONVENTION]
-
-[TARGET_DWARF_HANDLE_FRAME_UNSPEC]
-.. function:: void TARGET_DWARF_HANDLE_FRAME_UNSPEC (const char *label, rtx pattern, int index)
-
- This target hook allows the backend to emit frame-related insns that
- contain UNSPECs or UNSPEC_VOLATILEs. The DWARF 2 call frame debugging
- info engine will invoke it on insns of the form
-
- .. code-block:: c++
-
- (set (reg) (unspec [...] UNSPEC_INDEX))
-
- and
-
- .. code-block:: c++
-
- (set (reg) (unspec_volatile [...] UNSPECV_INDEX)).
-
- to let the backend emit the call frame instructions. :samp:`{label}` is
- the CFI label attached to the insn, :samp:`{pattern}` is the pattern of
- the insn and :samp:`{index}` is ``UNSPEC_INDEX`` or ``UNSPECV_INDEX``.
-
-[TARGET_DWARF_HANDLE_FRAME_UNSPEC]
-
-[TARGET_DWARF_POLY_INDETERMINATE_VALUE]
-.. function:: unsigned int TARGET_DWARF_POLY_INDETERMINATE_VALUE (unsigned int i, unsigned int *factor, int *offset)
-
- Express the value of ``poly_int`` indeterminate :samp:`{i}` as a DWARF
- expression, with :samp:`{i}` counting from 1. Return the number of a DWARF
- register :samp:`{R}` and set :samp:`*{factor}` and :samp:`*{offset}` such
- that the value of the indeterminate is:
-
- .. code-block:: c++
-
- value_of(R) / factor - offset
-
- A target only needs to define this hook if it sets
- :samp:`NUM_POLY_INT_COEFFS` to a value greater than 1.
-
-[TARGET_DWARF_POLY_INDETERMINATE_VALUE]
-
-[TARGET_STACK_PROTECT_GUARD]
-.. function:: tree TARGET_STACK_PROTECT_GUARD (void)
-
- This hook returns a ``DECL`` node for the external variable to use
- for the stack protection guard. This variable is initialized by the
- runtime to some random value and is used to initialize the guard value
- that is placed at the top of the local stack frame. The type of this
- variable must be ``ptr_type_node``.
-
- The default version of this hook creates a variable called
- :samp:`__stack_chk_guard`, which is normally defined in :samp:`libgcc2.c`.
-
-[TARGET_STACK_PROTECT_GUARD]
-
-[TARGET_STACK_PROTECT_FAIL]
-.. function:: tree TARGET_STACK_PROTECT_FAIL (void)
-
- This hook returns a ``CALL_EXPR`` that alerts the runtime that the
- stack protect guard variable has been modified. This expression should
- involve a call to a ``noreturn`` function.
-
- The default version of this hook invokes a function called
- :samp:`__stack_chk_fail`, taking no arguments. This function is
- normally defined in :samp:`libgcc2.c`.
-
-[TARGET_STACK_PROTECT_FAIL]
-
-[TARGET_STACK_PROTECT_RUNTIME_ENABLED_P]
-.. function:: bool TARGET_STACK_PROTECT_RUNTIME_ENABLED_P (void)
-
- Returns true if the target wants GCC's default stack protect runtime support,
- otherwise return false. The default implementation always returns true.
-
-[TARGET_STACK_PROTECT_RUNTIME_ENABLED_P]
-
-[TARGET_HAVE_SPECULATION_SAFE_VALUE]
-.. function:: bool TARGET_HAVE_SPECULATION_SAFE_VALUE (bool active)
-
- This hook is used to determine the level of target support for
- ``__builtin_speculation_safe_value``. If called with an argument
- of false, it returns true if the target has been modified to support
- this builtin. If called with an argument of true, it returns true
- if the target requires active mitigation execution might be speculative.
-
- The default implementation returns false if the target does not define
- a pattern named ``speculation_barrier``. Else it returns true
- for the first case and whether the pattern is enabled for the current
- compilation for the second case.
-
- For targets that have no processors that can execute instructions
- speculatively an alternative implemenation of this hook is available:
- simply redefine this hook to ``speculation_safe_value_not_needed``
- along with your other target hooks.
-
-[TARGET_HAVE_SPECULATION_SAFE_VALUE]
-
-[TARGET_SPECULATION_SAFE_VALUE]
-.. function:: rtx TARGET_SPECULATION_SAFE_VALUE (machine_mode mode, rtx result, rtx val, rtx failval)
-
- This target hook can be used to generate a target-specific code
- sequence that implements the ``__builtin_speculation_safe_value``
- built-in function. The function must always return :samp:`{val}` in
- :samp:`{result}` in mode :samp:`{mode}` when the cpu is not executing
- speculatively, but must never return that when speculating until it
- is known that the speculation will not be unwound. The hook supports
- two primary mechanisms for implementing the requirements. The first
- is to emit a speculation barrier which forces the processor to wait
- until all prior speculative operations have been resolved; the second
- is to use a target-specific mechanism that can track the speculation
- state and to return :samp:`{failval}` if it can determine that
- speculation must be unwound at a later time.
-
- The default implementation simply copies :samp:`{val}` to :samp:`{result}` and
- emits a ``speculation_barrier`` instruction if that is defined.
-
-[TARGET_SPECULATION_SAFE_VALUE]
-
-[TARGET_PREDICT_DOLOOP_P]
-.. function:: bool TARGET_PREDICT_DOLOOP_P (class loop *loop)
-
- Return true if we can predict it is possible to use a low-overhead loop
- for a particular loop. The parameter :samp:`{loop}` is a pointer to the loop.
- This target hook is required only when the target supports low-overhead
- loops, and will help ivopts to make some decisions.
- The default version of this hook returns false.
-
-[TARGET_PREDICT_DOLOOP_P]
-
-[TARGET_HAVE_COUNT_REG_DECR_P]
-.. c:var:: bool TARGET_HAVE_COUNT_REG_DECR_P
-
- Return true if the target supports hardware count register for decrement
- and branch.
- The default value is false.
-
-[TARGET_HAVE_COUNT_REG_DECR_P]
-
-[TARGET_DOLOOP_COST_FOR_GENERIC]
-.. c:var:: int64_t TARGET_DOLOOP_COST_FOR_GENERIC
-
- One IV candidate dedicated for doloop is introduced in IVOPTs, we can
- calculate the computation cost of adopting it to any generic IV use by
- function get_computation_cost as before. But for targets which have
- hardware count register support for decrement and branch, it may have to
- move IV value from hardware count register to general purpose register
- while doloop IV candidate is used for generic IV uses. It probably takes
- expensive penalty. This hook allows target owners to define the cost for
- this especially for generic IV uses.
- The default value is zero.
-
-[TARGET_DOLOOP_COST_FOR_GENERIC]
-
-[TARGET_DOLOOP_COST_FOR_ADDRESS]
-.. c:var:: int64_t TARGET_DOLOOP_COST_FOR_ADDRESS
-
- One IV candidate dedicated for doloop is introduced in IVOPTs, we can
- calculate the computation cost of adopting it to any address IV use by
- function get_computation_cost as before. But for targets which have
- hardware count register support for decrement and branch, it may have to
- move IV value from hardware count register to general purpose register
- while doloop IV candidate is used for address IV uses. It probably takes
- expensive penalty. This hook allows target owners to define the cost for
- this escpecially for address IV uses.
- The default value is zero.
-
-[TARGET_DOLOOP_COST_FOR_ADDRESS]
-
-[TARGET_CAN_USE_DOLOOP_P]
-.. function:: bool TARGET_CAN_USE_DOLOOP_P (const widest_int &iterations, const widest_int &iterations_max, unsigned int loop_depth, bool entered_at_top)
-
- Return true if it is possible to use low-overhead loops (``doloop_end``
- and ``doloop_begin``) for a particular loop. :samp:`{iterations}` gives the
- exact number of iterations, or 0 if not known. :samp:`{iterations_max}` gives
- the maximum number of iterations, or 0 if not known. :samp:`{loop_depth}` is
- the nesting depth of the loop, with 1 for innermost loops, 2 for loops that
- contain innermost loops, and so on. :samp:`{entered_at_top}` is true if the
- loop is only entered from the top.
-
- This hook is only used if ``doloop_end`` is available. The default
- implementation returns true. You can use ``can_use_doloop_if_innermost``
- if the loop must be the innermost, and if there are no other restrictions.
-
-[TARGET_CAN_USE_DOLOOP_P]
-
-[TARGET_INVALID_WITHIN_DOLOOP]
-.. function:: const char * TARGET_INVALID_WITHIN_DOLOOP (const rtx_insn *insn)
-
- Take an instruction in :samp:`{insn}` and return NULL if it is valid within a
- low-overhead loop, otherwise return a string explaining why doloop
- could not be applied.
-
- Many targets use special registers for low-overhead looping. For any
- instruction that clobbers these this function should return a string indicating
- the reason why the doloop could not be applied.
- By default, the RTL loop optimizer does not use a present doloop pattern for
- loops containing function calls or branch on table instructions.
-
-[TARGET_INVALID_WITHIN_DOLOOP]
-
-[TARGET_PREFERRED_DOLOOP_MODE]
-.. function:: machine_mode TARGET_PREFERRED_DOLOOP_MODE (machine_mode mode)
-
- This hook takes a :samp:`{mode}` for a doloop IV, where ``mode`` is the
- original mode for the operation. If the target prefers an alternate
- ``mode`` for the operation, then this hook should return that mode;
- otherwise the original ``mode`` should be returned. For example, on a
- 64-bit target, ``DImode`` might be preferred over ``SImode``. Both the
- original and the returned modes should be ``MODE_INT``.
-
-[TARGET_PREFERRED_DOLOOP_MODE]
-
-[TARGET_LEGITIMATE_COMBINED_INSN]
-.. function:: bool TARGET_LEGITIMATE_COMBINED_INSN (rtx_insn *insn)
-
- Take an instruction in :samp:`{insn}` and return ``false`` if the instruction
- is not appropriate as a combination of two or more instructions. The
- default is to accept all instructions.
-
-[TARGET_LEGITIMATE_COMBINED_INSN]
-
-[TARGET_VALID_DLLIMPORT_ATTRIBUTE_P]
-.. function:: bool TARGET_VALID_DLLIMPORT_ATTRIBUTE_P (const_tree decl)
-
- :samp:`{decl}` is a variable or function with ``__attribute__((dllimport))``
- specified. Use this hook if the target needs to add extra validation
- checks to ``handle_dll_attribute``.
-
-[TARGET_VALID_DLLIMPORT_ATTRIBUTE_P]
-
-[TARGET_CONST_ANCHOR]
-.. c:var:: unsigned HOST_WIDE_INT TARGET_CONST_ANCHOR
-
- On some architectures it can take multiple instructions to synthesize
- a constant. If there is another constant already in a register that
- is close enough in value then it is preferable that the new constant
- is computed from this register using immediate addition or
- subtraction. We accomplish this through CSE. Besides the value of
- the constant we also add a lower and an upper constant anchor to the
- available expressions. These are then queried when encountering new
- constants. The anchors are computed by rounding the constant up and
- down to a multiple of the value of ``TARGET_CONST_ANCHOR``.
- ``TARGET_CONST_ANCHOR`` should be the maximum positive value
- accepted by immediate-add plus one. We currently assume that the
- value of ``TARGET_CONST_ANCHOR`` is a power of 2. For example, on
- MIPS, where add-immediate takes a 16-bit signed value,
- ``TARGET_CONST_ANCHOR`` is set to :samp:`0x8000`. The default value
- is zero, which disables this optimization.
-
-[TARGET_CONST_ANCHOR]
-
-[TARGET_MEMMODEL_CHECK]
-.. function:: unsigned HOST_WIDE_INT TARGET_MEMMODEL_CHECK (unsigned HOST_WIDE_INT val)
-
- Validate target specific memory model mask bits. When NULL no target specific
- memory model bits are allowed.
-
-[TARGET_MEMMODEL_CHECK]
-
-[TARGET_ASAN_SHADOW_OFFSET]
-.. function:: unsigned HOST_WIDE_INT TARGET_ASAN_SHADOW_OFFSET (void)
-
- Return the offset bitwise ored into shifted address to get corresponding
- Address Sanitizer shadow memory address. NULL if Address Sanitizer is not
- supported by the target. May return 0 if Address Sanitizer is not supported
- by a subtarget.
-
-[TARGET_ASAN_SHADOW_OFFSET]
-
-[TARGET_PROMOTE_FUNCTION_MODE]
-.. function:: machine_mode TARGET_PROMOTE_FUNCTION_MODE (const_tree type, machine_mode mode, int *punsignedp, const_tree funtype, int for_return)
-
- Like ``PROMOTE_MODE``, but it is applied to outgoing function arguments or
- function return values. The target hook should return the new mode
- and possibly change ``*punsignedp`` if the promotion should
- change signedness. This function is called only for scalar *or
- pointer* types.
-
- :samp:`{for_return}` allows to distinguish the promotion of arguments and
- return values. If it is ``1``, a return value is being promoted and
- ``TARGET_FUNCTION_VALUE`` must perform the same promotions done here.
- If it is ``2``, the returned mode should be that of the register in
- which an incoming parameter is copied, or the outgoing result is computed;
- then the hook should return the same mode as ``promote_mode``, though
- the signedness may be different.
-
- :samp:`{type}` can be NULL when promoting function arguments of libcalls.
-
- The default is to not promote arguments and return values. You can
- also define the hook to ``default_promote_function_mode_always_promote``
- if you would like to apply the same rules given by ``PROMOTE_MODE``.
-
-[TARGET_PROMOTE_FUNCTION_MODE]
-
-[TARGET_PROMOTE_PROTOTYPES]
-.. function:: bool TARGET_PROMOTE_PROTOTYPES (const_tree fntype)
-
- This target hook returns ``true`` if an argument declared in a
- prototype as an integral type smaller than ``int`` should actually be
- passed as an ``int``. In addition to avoiding errors in certain
- cases of mismatch, it also makes for better code on certain machines.
- The default is to not promote prototypes.
-
-[TARGET_PROMOTE_PROTOTYPES]
-
-[TARGET_STRUCT_VALUE_RTX]
-.. function:: rtx TARGET_STRUCT_VALUE_RTX (tree fndecl, int incoming)
-
- This target hook should return the location of the structure value
- address (normally a ``mem`` or ``reg``), or 0 if the address is
- passed as an 'invisible' first argument. Note that :samp:`{fndecl}` may
- be ``NULL``, for libcalls. You do not need to define this target
- hook if the address is always passed as an 'invisible' first
- argument.
-
- On some architectures the place where the structure value address
- is found by the called function is not the same place that the
- caller put it. This can be due to register windows, or it could
- be because the function prologue moves it to a different place.
- :samp:`{incoming}` is ``1`` or ``2`` when the location is needed in
- the context of the called function, and ``0`` in the context of
- the caller.
-
- If :samp:`{incoming}` is nonzero and the address is to be found on the
- stack, return a ``mem`` which refers to the frame pointer. If
- :samp:`{incoming}` is ``2``, the result is being used to fetch the
- structure value address at the beginning of a function. If you need
- to emit adjusting code, you should do it at this point.
-
-[TARGET_STRUCT_VALUE_RTX]
-
-[TARGET_OMIT_STRUCT_RETURN_REG]
-.. c:var:: bool TARGET_OMIT_STRUCT_RETURN_REG
-
- Normally, when a function returns a structure by memory, the address
- is passed as an invisible pointer argument, but the compiler also
- arranges to return the address from the function like it would a normal
- pointer return value. Define this to true if that behavior is
- undesirable on your target.
-
-[TARGET_OMIT_STRUCT_RETURN_REG]
-
-[TARGET_RETURN_IN_MEMORY]
-.. function:: bool TARGET_RETURN_IN_MEMORY (const_tree type, const_tree fntype)
-
- This target hook should return a nonzero value to say to return the
- function value in memory, just as large structures are always returned.
- Here :samp:`{type}` will be the data type of the value, and :samp:`{fntype}`
- will be the type of the function doing the returning, or ``NULL`` for
- libcalls.
-
- Note that values of mode ``BLKmode`` must be explicitly handled
- by this function. Also, the option :option:`-fpcc-struct-return`
- takes effect regardless of this macro. On most systems, it is
- possible to leave the hook undefined; this causes a default
- definition to be used, whose value is the constant 1 for ``BLKmode``
- values, and 0 otherwise.
-
- Do not use this hook to indicate that structures and unions should always
- be returned in memory. You should instead use ``DEFAULT_PCC_STRUCT_RETURN``
- to indicate this.
-
-[TARGET_RETURN_IN_MEMORY]
-
-[TARGET_RETURN_IN_MSB]
-.. function:: bool TARGET_RETURN_IN_MSB (const_tree type)
-
- This hook should return true if values of type :samp:`{type}` are returned
- at the most significant end of a register (in other words, if they are
- padded at the least significant end). You can assume that :samp:`{type}`
- is returned in a register; the caller is required to check this.
-
- Note that the register provided by ``TARGET_FUNCTION_VALUE`` must
- be able to hold the complete return value. For example, if a 1-, 2-
- or 3-byte structure is returned at the most significant end of a
- 4-byte register, ``TARGET_FUNCTION_VALUE`` should provide an
- ``SImode`` rtx.
-
-[TARGET_RETURN_IN_MSB]
-
-[TARGET_PASS_BY_REFERENCE]
-.. function:: bool TARGET_PASS_BY_REFERENCE (cumulative_args_t cum, const function_arg_info &arg)
-
- This target hook should return ``true`` if argument :samp:`{arg}` at the
- position indicated by :samp:`{cum}` should be passed by reference. This
- predicate is queried after target independent reasons for being
- passed by reference, such as ``TREE_ADDRESSABLE (arg.type)``.
-
- If the hook returns true, a copy of that argument is made in memory and a
- pointer to the argument is passed instead of the argument itself.
- The pointer is passed in whatever way is appropriate for passing a pointer
- to that type.
-
-[TARGET_PASS_BY_REFERENCE]
-
-[TARGET_EXPAND_BUILTIN_SAVEREGS]
-.. function:: rtx TARGET_EXPAND_BUILTIN_SAVEREGS (void)
-
- If defined, this hook produces the machine-specific code for a call to
- ``__builtin_saveregs``. This code will be moved to the very
- beginning of the function, before any parameter access are made. The
- return value of this function should be an RTX that contains the value
- to use as the return of ``__builtin_saveregs``.
-
-[TARGET_EXPAND_BUILTIN_SAVEREGS]
-
-[TARGET_SETUP_INCOMING_VARARGS]
-.. function:: void TARGET_SETUP_INCOMING_VARARGS (cumulative_args_t args_so_far, const function_arg_info &arg, int *pretend_args_size, int second_time)
-
- This target hook offers an alternative to using
- ``__builtin_saveregs`` and defining the hook
- ``TARGET_EXPAND_BUILTIN_SAVEREGS``. Use it to store the anonymous
- register arguments into the stack so that all the arguments appear to
- have been passed consecutively on the stack. Once this is done, you can
- use the standard implementation of varargs that works for machines that
- pass all their arguments on the stack.
-
- The argument :samp:`{args_so_far}` points to the ``CUMULATIVE_ARGS`` data
- structure, containing the values that are obtained after processing the
- named arguments. The argument :samp:`{arg}` describes the last of these named
- arguments. The argument :samp:`{arg}` should not be used if the function type
- satisfies ``TYPE_NO_NAMED_ARGS_STDARG_P``, since in that case there are
- no named arguments and all arguments are accessed with ``va_arg``.
-
- The target hook should do two things: first, push onto the stack all the
- argument registers *not* used for the named arguments, and second,
- store the size of the data thus pushed into the ``int`` -valued
- variable pointed to by :samp:`{pretend_args_size}`. The value that you
- store here will serve as additional offset for setting up the stack
- frame.
-
- Because you must generate code to push the anonymous arguments at
- compile time without knowing their data types,
- ``TARGET_SETUP_INCOMING_VARARGS`` is only useful on machines that
- have just a single category of argument register and use it uniformly
- for all data types.
-
- If the argument :samp:`{second_time}` is nonzero, it means that the
- arguments of the function are being analyzed for the second time. This
- happens for an inline function, which is not actually compiled until the
- end of the source file. The hook ``TARGET_SETUP_INCOMING_VARARGS`` should
- not generate any instructions in this case.
-
-[TARGET_SETUP_INCOMING_VARARGS]
-
-[TARGET_CALL_ARGS]
-.. function:: void TARGET_CALL_ARGS (rtx, tree)
-
- While generating RTL for a function call, this target hook is invoked once
- for each argument passed to the function, either a register returned by
- ``TARGET_FUNCTION_ARG`` or a memory location. It is called just
- before the point where argument registers are stored. The type of the
- function to be called is also passed as the second argument; it is
- ``NULL_TREE`` for libcalls. The ``TARGET_END_CALL_ARGS`` hook is
- invoked just after the code to copy the return reg has been emitted.
- This functionality can be used to perform special setup of call argument
- registers if a target needs it.
- For functions without arguments, the hook is called once with ``pc_rtx``
- passed instead of an argument register.
- Most ports do not need to implement anything for this hook.
-
-[TARGET_CALL_ARGS]
-
-[TARGET_END_CALL_ARGS]
-.. function:: void TARGET_END_CALL_ARGS (void)
-
- This target hook is invoked while generating RTL for a function call,
- just after the point where the return reg is copied into a pseudo. It
- signals that all the call argument and return registers for the just
- emitted call are now no longer in use.
- Most ports do not need to implement anything for this hook.
-
-[TARGET_END_CALL_ARGS]
-
-[TARGET_PUSH_ARGUMENT]
-.. function:: bool TARGET_PUSH_ARGUMENT (unsigned int npush)
-
- This target hook returns ``true`` if push instructions will be
- used to pass outgoing arguments. When the push instruction usage is
- optional, :samp:`{npush}` is nonzero to indicate the number of bytes to
- push. Otherwise, :samp:`{npush}` is zero. If the target machine does not
- have a push instruction or push instruction should be avoided,
- ``false`` should be returned. That directs GCC to use an alternate
- strategy: to allocate the entire argument block and then store the
- arguments into it. If this target hook may return ``true``,
- ``PUSH_ROUNDING`` must be defined.
-
-[TARGET_PUSH_ARGUMENT]
-
-[TARGET_STRICT_ARGUMENT_NAMING]
-.. function:: bool TARGET_STRICT_ARGUMENT_NAMING (cumulative_args_t ca)
-
- Define this hook to return ``true`` if the location where a function
- argument is passed depends on whether or not it is a named argument.
-
- This hook controls how the :samp:`{named}` argument to ``TARGET_FUNCTION_ARG``
- is set for varargs and stdarg functions. If this hook returns
- ``true``, the :samp:`{named}` argument is always true for named
- arguments, and false for unnamed arguments. If it returns ``false``,
- but ``TARGET_PRETEND_OUTGOING_VARARGS_NAMED`` returns ``true``,
- then all arguments are treated as named. Otherwise, all named arguments
- except the last are treated as named.
-
- You need not define this hook if it always returns ``false``.
-
-[TARGET_STRICT_ARGUMENT_NAMING]
-
-[TARGET_PRETEND_OUTGOING_VARARGS_NAMED]
-.. function:: bool TARGET_PRETEND_OUTGOING_VARARGS_NAMED (cumulative_args_t ca)
-
- If you need to conditionally change ABIs so that one works with
- ``TARGET_SETUP_INCOMING_VARARGS``, but the other works like neither
- ``TARGET_SETUP_INCOMING_VARARGS`` nor ``TARGET_STRICT_ARGUMENT_NAMING`` was
- defined, then define this hook to return ``true`` if
- ``TARGET_SETUP_INCOMING_VARARGS`` is used, ``false`` otherwise.
- Otherwise, you should not define this hook.
-
-[TARGET_PRETEND_OUTGOING_VARARGS_NAMED]
-
-[TARGET_SPLIT_COMPLEX_ARG]
-.. function:: bool TARGET_SPLIT_COMPLEX_ARG (const_tree type)
-
- This hook should return true if parameter of type :samp:`{type}` are passed
- as two scalar parameters. By default, GCC will attempt to pack complex
- arguments into the target's word size. Some ABIs require complex arguments
- to be split and treated as their individual components. For example, on
- AIX64, complex floats should be passed in a pair of floating point
- registers, even though a complex float would fit in one 64-bit floating
- point register.
-
- The default value of this hook is ``NULL``, which is treated as always
- false.
-
-[TARGET_SPLIT_COMPLEX_ARG]
-
-[TARGET_MUST_PASS_IN_STACK]
-.. function:: bool TARGET_MUST_PASS_IN_STACK (const function_arg_info &arg)
-
- This target hook should return ``true`` if we should not pass :samp:`{arg}`
- solely in registers. The file :samp:`expr.h` defines a
- definition that is usually appropriate, refer to :samp:`expr.h` for additional
- documentation.
-
-[TARGET_MUST_PASS_IN_STACK]
-
-[TARGET_CALLEE_COPIES]
-.. function:: bool TARGET_CALLEE_COPIES (cumulative_args_t cum, const function_arg_info &arg)
-
- The function argument described by the parameters to this hook is
- known to be passed by reference. The hook should return true if the
- function argument should be copied by the callee instead of copied
- by the caller.
-
- For any argument for which the hook returns true, if it can be
- determined that the argument is not modified, then a copy need
- not be generated.
-
- The default version of this hook always returns false.
-
-[TARGET_CALLEE_COPIES]
-
-[TARGET_ARG_PARTIAL_BYTES]
-.. function:: int TARGET_ARG_PARTIAL_BYTES (cumulative_args_t cum, const function_arg_info &arg)
-
- This target hook returns the number of bytes at the beginning of an
- argument that must be put in registers. The value must be zero for
- arguments that are passed entirely in registers or that are entirely
- pushed on the stack.
-
- On some machines, certain arguments must be passed partially in
- registers and partially in memory. On these machines, typically the
- first few words of arguments are passed in registers, and the rest
- on the stack. If a multi-word argument (a ``double`` or a
- structure) crosses that boundary, its first few words must be passed
- in registers and the rest must be pushed. This macro tells the
- compiler when this occurs, and how many bytes should go in registers.
-
- ``TARGET_FUNCTION_ARG`` for these arguments should return the first
- register to be used by the caller for this argument; likewise
- ``TARGET_FUNCTION_INCOMING_ARG``, for the called function.
-
-[TARGET_ARG_PARTIAL_BYTES]
-
-[TARGET_FUNCTION_ARG_ADVANCE]
-.. function:: void TARGET_FUNCTION_ARG_ADVANCE (cumulative_args_t ca, const function_arg_info &arg)
-
- This hook updates the summarizer variable pointed to by :samp:`{ca}` to
- advance past argument :samp:`{arg}` in the argument list. Once this is done,
- the variable :samp:`{cum}` is suitable for analyzing the *following*
- argument with ``TARGET_FUNCTION_ARG``, etc.
-
- This hook need not do anything if the argument in question was passed
- on the stack. The compiler knows how to track the amount of stack space
- used for arguments without any special help.
-
-[TARGET_FUNCTION_ARG_ADVANCE]
-
-[TARGET_FUNCTION_ARG_OFFSET]
-.. function:: HOST_WIDE_INT TARGET_FUNCTION_ARG_OFFSET (machine_mode mode, const_tree type)
-
- This hook returns the number of bytes to add to the offset of an
- argument of type :samp:`{type}` and mode :samp:`{mode}` when passed in memory.
- This is needed for the SPU, which passes ``char`` and ``short``
- arguments in the preferred slot that is in the middle of the quad word
- instead of starting at the top. The default implementation returns 0.
-
-[TARGET_FUNCTION_ARG_OFFSET]
-
-[TARGET_FUNCTION_ARG_PADDING]
-.. function:: pad_direction TARGET_FUNCTION_ARG_PADDING (machine_mode mode, const_tree type)
-
- This hook determines whether, and in which direction, to pad out
- an argument of mode :samp:`{mode}` and type :samp:`{type}`. It returns
- ``PAD_UPWARD`` to insert padding above the argument, ``PAD_DOWNWARD``
- to insert padding below the argument, or ``PAD_NONE`` to inhibit padding.
-
- The *amount* of padding is not controlled by this hook, but by
- ``TARGET_FUNCTION_ARG_ROUND_BOUNDARY``. It is always just enough
- to reach the next multiple of that boundary.
-
- This hook has a default definition that is right for most systems.
- For little-endian machines, the default is to pad upward. For
- big-endian machines, the default is to pad downward for an argument of
- constant size shorter than an ``int``, and upward otherwise.
-
-[TARGET_FUNCTION_ARG_PADDING]
-
-[TARGET_FUNCTION_ARG]
-.. function:: rtx TARGET_FUNCTION_ARG (cumulative_args_t ca, const function_arg_info &arg)
-
- Return an RTX indicating whether function argument :samp:`{arg}` is passed
- in a register and if so, which register. Argument :samp:`{ca}` summarizes all
- the previous arguments.
-
- The return value is usually either a ``reg`` RTX for the hard
- register in which to pass the argument, or zero to pass the argument
- on the stack.
-
- The value of the expression can also be a ``parallel`` RTX. This is
- used when an argument is passed in multiple locations. The mode of the
- ``parallel`` should be the mode of the entire argument. The
- ``parallel`` holds any number of ``expr_list`` pairs; each one
- describes where part of the argument is passed. In each
- ``expr_list`` the first operand must be a ``reg`` RTX for the hard
- register in which to pass this part of the argument, and the mode of the
- register RTX indicates how large this part of the argument is. The
- second operand of the ``expr_list`` is a ``const_int`` which gives
- the offset in bytes into the entire argument of where this part starts.
- As a special exception the first ``expr_list`` in the ``parallel``
- RTX may have a first operand of zero. This indicates that the entire
- argument is also stored on the stack.
-
- The last time this hook is called, it is called with ``MODE ==
- VOIDmode``, and its result is passed to the ``call`` or ``call_value``
- pattern as operands 2 and 3 respectively.
-
- .. index:: stdarg.h and register arguments
-
- The usual way to make the ISO library :samp:`stdarg.h` work on a
- machine where some arguments are usually passed in registers, is to
- cause nameless arguments to be passed on the stack instead. This is
- done by making ``TARGET_FUNCTION_ARG`` return 0 whenever
- :samp:`{named}` is ``false``.
-
- .. index:: TARGET_MUST_PASS_IN_STACK, and TARGET_FUNCTION_ARG, REG_PARM_STACK_SPACE, and TARGET_FUNCTION_ARG
-
- You may use the hook ``targetm.calls.must_pass_in_stack``
- in the definition of this macro to determine if this argument is of a
- type that must be passed in the stack. If ``REG_PARM_STACK_SPACE``
- is not defined and ``TARGET_FUNCTION_ARG`` returns nonzero for such an
- argument, the compiler will abort. If ``REG_PARM_STACK_SPACE`` is
- defined, the argument will be computed in the stack and then loaded into
- a register.
-
-[TARGET_FUNCTION_ARG]
-
-[TARGET_FUNCTION_INCOMING_ARG]
-.. function:: rtx TARGET_FUNCTION_INCOMING_ARG (cumulative_args_t ca, const function_arg_info &arg)
-
- Define this hook if the caller and callee on the target have different
- views of where arguments are passed. Also define this hook if there are
- functions that are never directly called, but are invoked by the hardware
- and which have nonstandard calling conventions.
-
- In this case ``TARGET_FUNCTION_ARG`` computes the register in
- which the caller passes the value, and
- ``TARGET_FUNCTION_INCOMING_ARG`` should be defined in a similar
- fashion to tell the function being called where the arguments will
- arrive.
-
- ``TARGET_FUNCTION_INCOMING_ARG`` can also return arbitrary address
- computation using hard register, which can be forced into a register,
- so that it can be used to pass special arguments.
-
- If ``TARGET_FUNCTION_INCOMING_ARG`` is not defined,
- ``TARGET_FUNCTION_ARG`` serves both purposes.
-
-[TARGET_FUNCTION_INCOMING_ARG]
-
-[TARGET_FUNCTION_ARG_BOUNDARY]
-.. function:: unsigned int TARGET_FUNCTION_ARG_BOUNDARY (machine_mode mode, const_tree type)
-
- This hook returns the alignment boundary, in bits, of an argument
- with the specified mode and type. The default hook returns
- ``PARM_BOUNDARY`` for all arguments.
-
-[TARGET_FUNCTION_ARG_BOUNDARY]
-
-[TARGET_FUNCTION_ARG_ROUND_BOUNDARY]
-.. function:: unsigned int TARGET_FUNCTION_ARG_ROUND_BOUNDARY (machine_mode mode, const_tree type)
-
- Normally, the size of an argument is rounded up to ``PARM_BOUNDARY``,
- which is the default value for this hook. You can define this hook to
- return a different value if an argument size must be rounded to a larger
- value.
-
-[TARGET_FUNCTION_ARG_ROUND_BOUNDARY]
-
-[TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN]
-.. function:: const char * TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN (const_tree typelist, const_tree funcdecl, const_tree val)
-
- If defined, this macro returns the diagnostic message when it is
- illegal to pass argument :samp:`{val}` to function :samp:`{funcdecl}`
- with prototype :samp:`{typelist}`.
-
-[TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN]
-
-[TARGET_FUNCTION_VALUE]
-.. function:: rtx TARGET_FUNCTION_VALUE (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing)
-
- Define this to return an RTX representing the place where a function
- returns or receives a value of data type :samp:`{ret_type}`, a tree node
- representing a data type. :samp:`{fn_decl_or_type}` is a tree node
- representing ``FUNCTION_DECL`` or ``FUNCTION_TYPE`` of a
- function being called. If :samp:`{outgoing}` is false, the hook should
- compute the register in which the caller will see the return value.
- Otherwise, the hook should return an RTX representing the place where
- a function returns a value.
-
- On many machines, only ``TYPE_MODE (ret_type)`` is relevant.
- (Actually, on most machines, scalar values are returned in the same
- place regardless of mode.) The value of the expression is usually a
- ``reg`` RTX for the hard register where the return value is stored.
- The value can also be a ``parallel`` RTX, if the return value is in
- multiple places. See ``TARGET_FUNCTION_ARG`` for an explanation of the
- ``parallel`` form. Note that the callee will populate every
- location specified in the ``parallel``, but if the first element of
- the ``parallel`` contains the whole return value, callers will use
- that element as the canonical location and ignore the others. The m68k
- port uses this type of ``parallel`` to return pointers in both
- :samp:`%a0` (the canonical location) and :samp:`%d0`.
-
- If ``TARGET_PROMOTE_FUNCTION_RETURN`` returns true, you must apply
- the same promotion rules specified in ``PROMOTE_MODE`` if
- :samp:`{valtype}` is a scalar type.
-
- If the precise function being called is known, :samp:`{func}` is a tree
- node (``FUNCTION_DECL``) for it; otherwise, :samp:`{func}` is a null
- pointer. This makes it possible to use a different value-returning
- convention for specific functions when all their calls are
- known.
-
- Some target machines have 'register windows' so that the register in
- which a function returns its value is not the same as the one in which
- the caller sees the value. For such machines, you should return
- different RTX depending on :samp:`{outgoing}`.
-
- ``TARGET_FUNCTION_VALUE`` is not used for return values with
- aggregate data types, because these are returned in another way. See
- ``TARGET_STRUCT_VALUE_RTX`` and related macros, below.
-
-[TARGET_FUNCTION_VALUE]
-
-[TARGET_LIBCALL_VALUE]
-.. function:: rtx TARGET_LIBCALL_VALUE (machine_mode mode, const_rtx fun)
-
- Define this hook if the back-end needs to know the name of the libcall
- function in order to determine where the result should be returned.
-
- The mode of the result is given by :samp:`{mode}` and the name of the called
- library function is given by :samp:`{fun}`. The hook should return an RTX
- representing the place where the library function result will be returned.
-
- If this hook is not defined, then LIBCALL_VALUE will be used.
-
-[TARGET_LIBCALL_VALUE]
-
-[TARGET_FUNCTION_VALUE_REGNO_P]
-.. function:: bool TARGET_FUNCTION_VALUE_REGNO_P (const unsigned int regno)
-
- A target hook that return ``true`` if :samp:`{regno}` is the number of a hard
- register in which the values of called function may come back.
-
- A register whose use for returning values is limited to serving as the
- second of a pair (for a value of type ``double``, say) need not be
- recognized by this target hook.
-
- If the machine has register windows, so that the caller and the called
- function use different registers for the return value, this target hook
- should recognize only the caller's register numbers.
-
- If this hook is not defined, then FUNCTION_VALUE_REGNO_P will be used.
-
-[TARGET_FUNCTION_VALUE_REGNO_P]
-
-[TARGET_FNTYPE_ABI]
-.. function:: const predefined_function_abi & TARGET_FNTYPE_ABI (const_tree type)
-
- Return the ABI used by a function with type :samp:`{type}` ; see the
- definition of ``predefined_function_abi`` for details of the ABI
- descriptor. Targets only need to define this hook if they support
- interoperability between several ABIs in the same translation unit.
-
-[TARGET_FNTYPE_ABI]
-
-[TARGET_INSN_CALLEE_ABI]
-.. function:: const predefined_function_abi & TARGET_INSN_CALLEE_ABI (const rtx_insn *insn)
-
- This hook returns a description of the ABI used by the target of
- call instruction :samp:`{insn}` ; see the definition of
- ``predefined_function_abi`` for details of the ABI descriptor.
- Only the global function ``insn_callee_abi`` should call this hook
- directly.
-
- Targets only need to define this hook if they support
- interoperability between several ABIs in the same translation unit.
-
-[TARGET_INSN_CALLEE_ABI]
-
-[TARGET_UPDATE_STACK_BOUNDARY]
-.. function:: void TARGET_UPDATE_STACK_BOUNDARY (void)
-
- Define this macro to update the current function stack boundary if
- necessary.
-
-[TARGET_UPDATE_STACK_BOUNDARY]
-
-[TARGET_GET_DRAP_RTX]
-.. function:: rtx TARGET_GET_DRAP_RTX (void)
-
- This hook should return an rtx for Dynamic Realign Argument Pointer (DRAP) if a
- different argument pointer register is needed to access the function's
- argument list due to stack realignment. Return ``NULL`` if no DRAP
- is needed.
-
-[TARGET_GET_DRAP_RTX]
-
-[TARGET_ZERO_CALL_USED_REGS]
-.. function:: HARD_REG_SET TARGET_ZERO_CALL_USED_REGS (HARD_REG_SET selected_regs)
-
- This target hook emits instructions to zero the subset of :samp:`{selected_regs}`
- that could conceivably contain values that are useful to an attacker.
- Return the set of registers that were actually cleared.
-
- For most targets, the returned set of registers is a subset of
- :samp:`{selected_regs}`, however, for some of the targets (for example MIPS),
- clearing some registers that are in the :samp:`{selected_regs}` requires
- clearing other call used registers that are not in the :samp:`{selected_regs}`,
- under such situation, the returned set of registers must be a subset of all
- call used registers.
-
- The default implementation uses normal move instructions to zero
- all the registers in :samp:`{selected_regs}`. Define this hook if the
- target has more efficient ways of zeroing certain registers,
- or if you believe that certain registers would never contain
- values that are useful to an attacker.
-
-[TARGET_ZERO_CALL_USED_REGS]
-
-[TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS]
-.. function:: bool TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS (void)
-
- When optimization is disabled, this hook indicates whether or not
- arguments should be allocated to stack slots. Normally, GCC allocates
- stacks slots for arguments when not optimizing in order to make
- debugging easier. However, when a function is declared with
- ``__attribute__((naked))``, there is no stack frame, and the compiler
- cannot safely move arguments from the registers in which they are passed
- to the stack. Therefore, this hook should return true in general, but
- false for naked functions. The default implementation always returns true.
-
-[TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS]
-
-[TARGET_STATIC_CHAIN]
-.. function:: rtx TARGET_STATIC_CHAIN (const_tree fndecl_or_type, bool incoming_p)
-
- This hook replaces the use of ``STATIC_CHAIN_REGNUM`` et al for
- targets that may use different static chain locations for different
- nested functions. This may be required if the target has function
- attributes that affect the calling conventions of the function and
- those calling conventions use different static chain locations.
-
- The default version of this hook uses ``STATIC_CHAIN_REGNUM`` et al.
-
- If the static chain is passed in memory, this hook should be used to
- provide rtx giving ``mem`` expressions that denote where they are stored.
- Often the ``mem`` expression as seen by the caller will be at an offset
- from the stack pointer and the ``mem`` expression as seen by the callee
- will be at an offset from the frame pointer.
-
- .. index:: stack_pointer_rtx, frame_pointer_rtx, arg_pointer_rtx
-
- The variables ``stack_pointer_rtx``, ``frame_pointer_rtx``, and
- ``arg_pointer_rtx`` will have been initialized and should be used
- to refer to those items.
-
-[TARGET_STATIC_CHAIN]
-
-[TARGET_TRAMPOLINE_INIT]
-.. function:: void TARGET_TRAMPOLINE_INIT (rtx m_tramp, tree fndecl, rtx static_chain)
-
- This hook is called to initialize a trampoline.
- :samp:`{m_tramp}` is an RTX for the memory block for the trampoline; :samp:`{fndecl}`
- is the ``FUNCTION_DECL`` for the nested function; :samp:`{static_chain}` is an
- RTX for the static chain value that should be passed to the function
- when it is called.
-
- If the target defines ``TARGET_ASM_TRAMPOLINE_TEMPLATE``, then the
- first thing this hook should do is emit a block move into :samp:`{m_tramp}`
- from the memory block returned by ``assemble_trampoline_template``.
- Note that the block move need only cover the constant parts of the
- trampoline. If the target isolates the variable parts of the trampoline
- to the end, not all ``TRAMPOLINE_SIZE`` bytes need be copied.
-
- If the target requires any other actions, such as flushing caches
- (possibly calling function maybe_emit_call_builtin___clear_cache) or
- enabling stack execution, these actions should be performed after
- initializing the trampoline proper.
-
-[TARGET_TRAMPOLINE_INIT]
-
-[TARGET_EMIT_CALL_BUILTIN___CLEAR_CACHE]
-.. function:: void TARGET_EMIT_CALL_BUILTIN___CLEAR_CACHE (rtx begin, rtx end)
-
- On targets that do not define a ``clear_cache`` insn expander,
- but that define the ``CLEAR_CACHE_INSN`` macro,
- maybe_emit_call_builtin___clear_cache relies on this target hook
- to clear an address range in the instruction cache.
-
- The default implementation calls the ``__clear_cache`` builtin,
- taking the assembler name from the builtin declaration. Overriding
- definitions may call alternate functions, with alternate calling
- conventions, or emit alternate RTX to perform the job.
-
-[TARGET_EMIT_CALL_BUILTIN___CLEAR_CACHE]
-
-[TARGET_TRAMPOLINE_ADJUST_ADDRESS]
-.. function:: rtx TARGET_TRAMPOLINE_ADJUST_ADDRESS (rtx addr)
-
- This hook should perform any machine-specific adjustment in
- the address of the trampoline. Its argument contains the address of the
- memory block that was passed to ``TARGET_TRAMPOLINE_INIT``. In case
- the address to be used for a function call should be different from the
- address at which the template was stored, the different address should
- be returned; otherwise :samp:`{addr}` should be returned unchanged.
- If this hook is not defined, :samp:`{addr}` will be used for function calls.
-
-[TARGET_TRAMPOLINE_ADJUST_ADDRESS]
-
-[TARGET_CUSTOM_FUNCTION_DESCRIPTORS]
-.. c:var:: int TARGET_CUSTOM_FUNCTION_DESCRIPTORS
-
- If the target can use GCC's generic descriptor mechanism for nested
- functions, define this hook to a power of 2 representing an unused bit
- in function pointers which can be used to differentiate descriptors at
- run time. This value gives the number of bytes by which descriptor
- pointers are misaligned compared to function pointers. For example, on
- targets that require functions to be aligned to a 4-byte boundary, a
- value of either 1 or 2 is appropriate unless the architecture already
- reserves the bit for another purpose, such as on ARM.
-
- Define this hook to 0 if the target implements ABI support for
- function descriptors in its standard calling sequence, like for example
- HPPA or IA-64.
-
- Using descriptors for nested functions
- eliminates the need for trampolines that reside on the stack and require
- it to be made executable.
-
-[TARGET_CUSTOM_FUNCTION_DESCRIPTORS]
-
-[TARGET_RETURN_POPS_ARGS]
-.. function:: poly_int64 TARGET_RETURN_POPS_ARGS (tree fundecl, tree funtype, poly_int64 size)
-
- This target hook returns 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.
-
- :samp:`{fundecl}` is a C variable whose value is a tree node that describes
- the function in question. Normally it is a node of type
- ``FUNCTION_DECL`` that describes the declaration of the function.
- From this you can obtain the ``DECL_ATTRIBUTES`` of the function.
-
- :samp:`{funtype}` is a C variable whose value is a tree node that
- describes the function in question. Normally it is a node of type
- ``FUNCTION_TYPE`` that describes the data type of the function.
- From this it is possible to obtain the data types of the value and
- arguments (if known).
-
- When a call to a library function is being considered, :samp:`{fundecl}`
- will contain an identifier node for the library function. Thus, if
- you need to distinguish among various library functions, you can do so
- by their names. Note that 'library function' in this context means
- a function used to perform arithmetic, whose name is known specially
- in the compiler and was not mentioned in the C code being compiled.
-
- :samp:`{size}` is the number of bytes of arguments passed on the
- stack. If a variable number of bytes is passed, it is zero, and
- argument popping will always be the responsibility of the calling function.
-
- On the VAX, all functions always pop their arguments, so the definition
- of this macro is :samp:`{size}`. On the 68000, using the standard
- calling convention, no functions pop their arguments, so the value of
- the macro is always 0 in this case. But an alternative calling
- convention is available in which functions that take a fixed number of
- arguments pop them but other functions (such as ``printf``) pop
- nothing (the caller pops all). When this convention is in use,
- :samp:`{funtype}` is examined to determine whether a function takes a fixed
- number of arguments.
-
-[TARGET_RETURN_POPS_ARGS]
-
-[TARGET_GET_RAW_RESULT_MODE]
-.. function:: fixed_size_mode TARGET_GET_RAW_RESULT_MODE (int regno)
-
- This target hook returns the mode to be used when accessing raw return
- registers in ``__builtin_return``. Define this macro if the value
- in :samp:`{reg_raw_mode}` is not correct.
-
-[TARGET_GET_RAW_RESULT_MODE]
-
-[TARGET_GET_RAW_ARG_MODE]
-.. function:: fixed_size_mode TARGET_GET_RAW_ARG_MODE (int regno)
-
- This target hook returns the mode to be used when accessing raw argument
- registers in ``__builtin_apply_args``. Define this macro if the value
- in :samp:`{reg_raw_mode}` is not correct.
-
-[TARGET_GET_RAW_ARG_MODE]
-
-[TARGET_EMPTY_RECORD_P]
-.. function:: bool TARGET_EMPTY_RECORD_P (const_tree type)
-
- This target hook returns true if the type is an empty record. The default
- is to return ``false``.
-
-[TARGET_EMPTY_RECORD_P]
-
-[TARGET_WARN_PARAMETER_PASSING_ABI]
-.. function:: void TARGET_WARN_PARAMETER_PASSING_ABI (cumulative_args_t ca, tree type)
-
- This target hook warns about the change in empty class parameter passing
- ABI.
-
-[TARGET_WARN_PARAMETER_PASSING_ABI]
-
-[TARGET_USE_PSEUDO_PIC_REG]
-.. function:: bool TARGET_USE_PSEUDO_PIC_REG (void)
-
- This hook should return 1 in case pseudo register should be created
- for pic_offset_table_rtx during function expand.
-
-[TARGET_USE_PSEUDO_PIC_REG]
-
-[TARGET_INIT_PIC_REG]
-.. function:: void TARGET_INIT_PIC_REG (void)
-
- Perform a target dependent initialization of pic_offset_table_rtx.
- This hook is called at the start of register allocation.
-
-[TARGET_INIT_PIC_REG]
-
-[TARGET_INVALID_CONVERSION]
-.. function:: const char * TARGET_INVALID_CONVERSION (const_tree fromtype, const_tree totype)
-
- If defined, this macro returns the diagnostic message when it is
- invalid to convert from :samp:`{fromtype}` to :samp:`{totype}`, or ``NULL``
- if validity should be determined by the front end.
-
-[TARGET_INVALID_CONVERSION]
-
-[TARGET_INVALID_UNARY_OP]
-.. function:: const char * TARGET_INVALID_UNARY_OP (int op, const_tree type)
-
- If defined, this macro returns the diagnostic message when it is
- invalid to apply operation :samp:`{op}` (where unary plus is denoted by
- ``CONVERT_EXPR``) to an operand of type :samp:`{type}`, or ``NULL``
- if validity should be determined by the front end.
-
-[TARGET_INVALID_UNARY_OP]
-
-[TARGET_INVALID_BINARY_OP]
-.. function:: const char * TARGET_INVALID_BINARY_OP (int op, const_tree type1, const_tree type2)
-
- If defined, this macro returns the diagnostic message when it is
- invalid to apply operation :samp:`{op}` to operands of types :samp:`{type1}`
- and :samp:`{type2}`, or ``NULL`` if validity should be determined by
- the front end.
-
-[TARGET_INVALID_BINARY_OP]
-
-[TARGET_PROMOTED_TYPE]
-.. function:: tree TARGET_PROMOTED_TYPE (const_tree type)
-
- If defined, this target hook returns the type to which values of
- :samp:`{type}` should be promoted when they appear in expressions,
- analogous to the integer promotions, or ``NULL_TREE`` to use the
- front end's normal promotion rules. This hook is useful when there are
- target-specific types with special promotion rules.
- This is currently used only by the C and C++ front ends.
-
-[TARGET_PROMOTED_TYPE]
-
-[TARGET_CONVERT_TO_TYPE]
-.. function:: tree TARGET_CONVERT_TO_TYPE (tree type, tree expr)
-
- If defined, this hook returns the result of converting :samp:`{expr}` to
- :samp:`{type}`. It should return the converted expression,
- or ``NULL_TREE`` to apply the front end's normal conversion rules.
- This hook is useful when there are target-specific types with special
- conversion rules.
- This is currently used only by the C and C++ front ends.
-
-[TARGET_CONVERT_TO_TYPE]
-
-[TARGET_VERIFY_TYPE_CONTEXT]
-.. function:: bool TARGET_VERIFY_TYPE_CONTEXT (location_t loc, type_context_kind context, const_tree type, bool silent_p)
-
- If defined, this hook returns false if there is a target-specific reason
- why type :samp:`{type}` cannot be used in the source language context described
- by :samp:`{context}`. When :samp:`{silent_p}` is false, the hook also reports an
- error against :samp:`{loc}` for invalid uses of :samp:`{type}`.
-
- Calls to this hook should be made through the global function
- ``verify_type_context``, which makes the :samp:`{silent_p}` parameter
- default to false and also handles ``error_mark_node``.
-
- The default implementation always returns true.
-
-[TARGET_VERIFY_TYPE_CONTEXT]
-
-[TARGET_CAN_CHANGE_MODE_CLASS]
-.. function:: bool TARGET_CAN_CHANGE_MODE_CLASS (machine_mode from, machine_mode to, reg_class_t rclass)
-
- This hook returns true if it is possible to bitcast values held in
- registers of class :samp:`{rclass}` from mode :samp:`{from}` to mode :samp:`{to}`
- and if doing so preserves the low-order bits that are common to both modes.
- The result is only meaningful if :samp:`{rclass}` has registers that can hold
- both ``from`` and ``to``. The default implementation returns true.
-
- As an example of when such bitcasting is invalid, loading 32-bit integer or
- floating-point objects into floating-point registers on Alpha extends them
- to 64 bits. Therefore loading a 64-bit object and then storing it as a
- 32-bit object does not store the low-order 32 bits, as would be the case
- for a normal register. Therefore, :samp:`alpha.h` defines
- ``TARGET_CAN_CHANGE_MODE_CLASS`` to return:
-
- .. code-block:: c++
-
- (GET_MODE_SIZE (from) == GET_MODE_SIZE (to)
- || !reg_classes_intersect_p (FLOAT_REGS, rclass))
-
- Even if storing from a register in mode :samp:`{to}` would be valid,
- if both :samp:`{from}` and ``raw_reg_mode`` for :samp:`{rclass}` are wider
- than ``word_mode``, then we must prevent :samp:`{to}` narrowing the
- mode. This happens when the middle-end assumes that it can load
- or store pieces of an :samp:`{N}` -word pseudo, and that the pseudo will
- eventually be allocated to :samp:`{N}` ``word_mode`` hard registers.
- Failure to prevent this kind of mode change will result in the
- entire ``raw_reg_mode`` being modified instead of the partial
- value that the middle-end intended.
-
-[TARGET_CAN_CHANGE_MODE_CLASS]
-
-[TARGET_IRA_CHANGE_PSEUDO_ALLOCNO_CLASS]
-.. function:: reg_class_t TARGET_IRA_CHANGE_PSEUDO_ALLOCNO_CLASS (int, reg_class_t, reg_class_t)
-
- A target hook which can change allocno class for given pseudo from
- allocno and best class calculated by IRA.
-
- The default version of this target hook always returns given class.
-
-[TARGET_IRA_CHANGE_PSEUDO_ALLOCNO_CLASS]
-
-[TARGET_LRA_P]
-.. function:: bool TARGET_LRA_P (void)
-
- A target hook which returns true if we use LRA instead of reload pass.
-
- The default version of this target hook returns true. New ports
- should use LRA, and existing ports are encouraged to convert.
-
-[TARGET_LRA_P]
-
-[TARGET_REGISTER_PRIORITY]
-.. function:: int TARGET_REGISTER_PRIORITY (int)
-
- A target hook which returns the register priority number to which the
- register :samp:`{hard_regno}` belongs to. The bigger the number, the
- more preferable the hard register usage (when all other conditions are
- the same). This hook can be used to prefer some hard register over
- others in LRA. For example, some x86-64 register usage needs
- additional prefix which makes instructions longer. The hook can
- return lower priority number for such registers make them less favorable
- and as result making the generated code smaller.
-
- The default version of this target hook returns always zero.
-
-[TARGET_REGISTER_PRIORITY]
-
-[TARGET_REGISTER_USAGE_LEVELING_P]
-.. function:: bool TARGET_REGISTER_USAGE_LEVELING_P (void)
-
- A target hook which returns true if we need register usage leveling.
- That means if a few hard registers are equally good for the
- assignment, we choose the least used hard register. The register
- usage leveling may be profitable for some targets. Don't use the
- usage leveling for targets with conditional execution or targets
- with big register files as it hurts if-conversion and cross-jumping
- optimizations.
-
- The default version of this target hook returns always false.
-
-[TARGET_REGISTER_USAGE_LEVELING_P]
-
-[TARGET_DIFFERENT_ADDR_DISPLACEMENT_P]
-.. function:: bool TARGET_DIFFERENT_ADDR_DISPLACEMENT_P (void)
-
- A target hook which returns true if an address with the same structure
- can have different maximal legitimate displacement. For example, the
- displacement can depend on memory mode or on operand combinations in
- the insn.
-
- The default version of this target hook returns always false.
-
-[TARGET_DIFFERENT_ADDR_DISPLACEMENT_P]
-
-[TARGET_SPILL_CLASS]
-.. function:: reg_class_t TARGET_SPILL_CLASS (reg_class_t, machine_mode)
-
- This hook defines a class of registers which could be used for spilling
- pseudos of the given mode and class, or ``NO_REGS`` if only memory
- should be used. Not defining this hook is equivalent to returning
- ``NO_REGS`` for all inputs.
-
-[TARGET_SPILL_CLASS]
-
-[TARGET_ADDITIONAL_ALLOCNO_CLASS_P]
-.. function:: bool TARGET_ADDITIONAL_ALLOCNO_CLASS_P (reg_class_t)
-
- This hook should return ``true`` if given class of registers should
- be an allocno class in any way. Usually RA uses only one register
- class from all classes containing the same register set. In some
- complicated cases, you need to have two or more such classes as
- allocno ones for RA correct work. Not defining this hook is
- equivalent to returning ``false`` for all inputs.
-
-[TARGET_ADDITIONAL_ALLOCNO_CLASS_P]
-
-[TARGET_CSTORE_MODE]
-.. function:: scalar_int_mode TARGET_CSTORE_MODE (enum insn_code icode)
-
- This hook defines the machine mode to use for the boolean result of
- conditional store patterns. The ICODE argument is the instruction code
- for the cstore being performed. Not definiting this hook is the same
- as accepting the mode encoded into operand 0 of the cstore expander
- patterns.
-
-[TARGET_CSTORE_MODE]
-
-[TARGET_COMPUTE_PRESSURE_CLASSES]
-.. function:: int TARGET_COMPUTE_PRESSURE_CLASSES (enum reg_class *pressure_classes)
-
- A target hook which lets a backend compute the set of pressure classes to
- be used by those optimization passes which take register pressure into
- account, as opposed to letting IRA compute them. It returns the number of
- register classes stored in the array :samp:`{pressure_classes}`.
-
-[TARGET_COMPUTE_PRESSURE_CLASSES]
-
-[TARGET_MEMBER_TYPE_FORCES_BLK]
-.. function:: bool TARGET_MEMBER_TYPE_FORCES_BLK (const_tree field, machine_mode mode)
-
- Return true if a structure, union or array containing :samp:`{field}` should
- be accessed using ``BLKMODE``.
-
- If :samp:`{field}` is the only field in the structure, :samp:`{mode}` is its
- mode, otherwise :samp:`{mode}` is VOIDmode. :samp:`{mode}` is provided in the
- case where structures of one field would require the structure's mode to
- retain the field's mode.
-
- Normally, this is not needed.
-
-[TARGET_MEMBER_TYPE_FORCES_BLK]
-
-[TARGET_EXPAND_DIVMOD_LIBFUNC]
-.. function:: void TARGET_EXPAND_DIVMOD_LIBFUNC (rtx libfunc, machine_mode mode, rtx op0, rtx op1, rtx *quot, rtx *rem)
-
- Define this hook for enabling divmod transform if the port does not have
- hardware divmod insn but defines target-specific divmod libfuncs.
-
-[TARGET_EXPAND_DIVMOD_LIBFUNC]
-
-[TARGET_SECONDARY_RELOAD]
-.. function:: reg_class_t TARGET_SECONDARY_RELOAD (bool in_p, rtx x, reg_class_t reload_class, machine_mode reload_mode, secondary_reload_info *sri)
-
- Many machines have some registers that cannot be copied directly to or
- from memory or even from other types of registers. An example is the
- :samp:`MQ` register, which on most machines, can only be copied to or
- from general registers, but not memory. Below, we shall be using the
- term 'intermediate register' when a move operation cannot be performed
- directly, but has to be done by copying the source into the intermediate
- register first, and then copying the intermediate register to the
- destination. An intermediate register always has the same mode as
- source and destination. Since it holds the actual value being copied,
- reload might apply optimizations to re-use an intermediate register
- and eliding the copy from the source when it can determine that the
- intermediate register still holds the required value.
-
- Another kind of secondary reload is required on some machines which
- allow copying all registers to and from memory, but require a scratch
- register for stores to some memory locations (e.g., those with symbolic
- address on the RT, and those with certain symbolic address on the SPARC
- when compiling PIC). Scratch registers need not have the same mode
- as the value being copied, and usually hold a different value than
- that being copied. Special patterns in the md file are needed to
- describe how the copy is performed with the help of the scratch register;
- these patterns also describe the number, register class(es) and mode(s)
- of the scratch register(s).
-
- In some cases, both an intermediate and a scratch register are required.
-
- For input reloads, this target hook is called with nonzero :samp:`{in_p}`,
- and :samp:`{x}` is an rtx that needs to be copied to a register of class
- :samp:`{reload_class}` in :samp:`{reload_mode}`. For output reloads, this target
- hook is called with zero :samp:`{in_p}`, and a register of class :samp:`{reload_class}`
- needs to be copied to rtx :samp:`{x}` in :samp:`{reload_mode}`.
-
- If copying a register of :samp:`{reload_class}` from/to :samp:`{x}` requires
- an intermediate register, the hook ``secondary_reload`` should
- return the register class required for this intermediate register.
- If no intermediate register is required, it should return NO_REGS.
- If more than one intermediate register is required, describe the one
- that is closest in the copy chain to the reload register.
-
- If scratch registers are needed, you also have to describe how to
- perform the copy from/to the reload register to/from this
- closest intermediate register. Or if no intermediate register is
- required, but still a scratch register is needed, describe the
- copy from/to the reload register to/from the reload operand :samp:`{x}`.
-
- You do this by setting ``sri->icode`` to the instruction code of a pattern
- in the md file which performs the move. Operands 0 and 1 are the output
- and input of this copy, respectively. Operands from operand 2 onward are
- for scratch operands. These scratch operands must have a mode, and a
- single-register-class
-
- .. [later: or memory]
-
- output constraint.
-
- When an intermediate register is used, the ``secondary_reload``
- hook will be called again to determine how to copy the intermediate
- register to/from the reload operand :samp:`{x}`, so your hook must also
- have code to handle the register class of the intermediate operand.
-
- .. [For later: maybe we'll allow multi-alternative reload patterns -
-
- .. the port maintainer could name a mov<mode> pattern that has clobbers -
-
- .. and match the constraints of input and output to determine the required
-
- .. alternative. A restriction would be that constraints used to match
-
- .. against reloads registers would have to be written as register class
-
- .. constraints, or we need a new target macro / hook that tells us if an
-
- .. arbitrary constraint can match an unknown register of a given class.
-
- .. Such a macro / hook would also be useful in other places.]
-
- :samp:`{x}` might be a pseudo-register or a ``subreg`` of a
- pseudo-register, which could either be in a hard register or in memory.
- Use ``true_regnum`` to find out; it will return -1 if the pseudo is
- in memory and the hard register number if it is in a register.
-
- Scratch operands in memory (constraint ``"=m"`` / ``"=&m"``) are
- currently not supported. For the time being, you will have to continue
- to use ``TARGET_SECONDARY_MEMORY_NEEDED`` for that purpose.
-
- ``copy_cost`` also uses this target hook to find out how values are
- copied. If you want it to include some extra cost for the need to allocate
- (a) scratch register(s), set ``sri->extra_cost`` to the additional cost.
- Or if two dependent moves are supposed to have a lower cost than the sum
- of the individual moves due to expected fortuitous scheduling and/or special
- forwarding logic, you can set ``sri->extra_cost`` to a negative amount.
-
-[TARGET_SECONDARY_RELOAD]
-
-[TARGET_SECONDARY_MEMORY_NEEDED]
-.. function:: bool TARGET_SECONDARY_MEMORY_NEEDED (machine_mode mode, reg_class_t class1, reg_class_t class2)
-
- Certain machines have the property that some registers cannot be copied
- to some other registers without using memory. Define this hook on
- those machines to return true if objects of mode :samp:`{m}` in registers
- of :samp:`{class1}` can only be copied to registers of class :samp:`{class2}` by
- storing a register of :samp:`{class1}` into memory and loading that memory
- location into a register of :samp:`{class2}`. The default definition returns
- false for all inputs.
-
-[TARGET_SECONDARY_MEMORY_NEEDED]
-
-[TARGET_SECONDARY_MEMORY_NEEDED_MODE]
-.. function:: machine_mode TARGET_SECONDARY_MEMORY_NEEDED_MODE (machine_mode mode)
-
- If ``TARGET_SECONDARY_MEMORY_NEEDED`` tells the compiler to use memory
- when moving between two particular registers of mode :samp:`{mode}`,
- this hook specifies the mode that the memory should have.
-
- The default depends on ``TARGET_LRA_P``. Without LRA, the default
- is to use a word-sized mode for integral modes that are smaller than a
- a word. This is right thing to do on most machines because it ensures
- that all bits of the register are copied and prevents accesses to the
- registers in a narrower mode, which some machines prohibit for
- floating-point registers.
-
- However, this default behavior is not correct on some machines, such as
- the DEC Alpha, that store short integers in floating-point registers
- differently than in integer registers. On those machines, the default
- widening will not work correctly and you must define this hook to
- suppress that widening in some cases. See the file :samp:`alpha.cc` for
- details.
-
- With LRA, the default is to use :samp:`{mode}` unmodified.
-
-[TARGET_SECONDARY_MEMORY_NEEDED_MODE]
-
-[TARGET_PREFERRED_RELOAD_CLASS]
-.. function:: reg_class_t TARGET_PREFERRED_RELOAD_CLASS (rtx x, reg_class_t rclass)
-
- A target hook that places additional restrictions on the register class
- to use when it is necessary to copy value :samp:`{x}` into a register in class
- :samp:`{rclass}`. The value is a register class; perhaps :samp:`{rclass}`, or perhaps
- another, smaller class.
-
- The default version of this hook always returns value of ``rclass`` argument.
-
- Sometimes returning a more restrictive class makes better code. For
- example, on the 68000, when :samp:`{x}` is an integer constant that is in range
- for a :samp:`moveq` instruction, the value of this macro is always
- ``DATA_REGS`` as long as :samp:`{rclass}` includes the data registers.
- Requiring a data register guarantees that a :samp:`moveq` will be used.
-
- One case where ``TARGET_PREFERRED_RELOAD_CLASS`` must not return
- :samp:`{rclass}` is if :samp:`{x}` is a legitimate constant which cannot be
- loaded into some register class. By returning ``NO_REGS`` you can
- force :samp:`{x}` into a memory location. For example, rs6000 can load
- immediate values into general-purpose registers, but does not have an
- instruction for loading an immediate value into a floating-point
- register, so ``TARGET_PREFERRED_RELOAD_CLASS`` returns ``NO_REGS`` when
- :samp:`{x}` is a floating-point constant. If the constant can't be loaded
- into any kind of register, code generation will be better if
- ``TARGET_LEGITIMATE_CONSTANT_P`` makes the constant illegitimate instead
- of using ``TARGET_PREFERRED_RELOAD_CLASS``.
-
- If an insn has pseudos in it after register allocation, reload will go
- through the alternatives and call repeatedly ``TARGET_PREFERRED_RELOAD_CLASS``
- to find the best one. Returning ``NO_REGS``, in this case, makes
- reload add a ``!`` in front of the constraint: the x86 back-end uses
- this feature to discourage usage of 387 registers when math is done in
- the SSE registers (and vice versa).
-
-[TARGET_PREFERRED_RELOAD_CLASS]
-
-[TARGET_PREFERRED_OUTPUT_RELOAD_CLASS]
-.. function:: reg_class_t TARGET_PREFERRED_OUTPUT_RELOAD_CLASS (rtx x, reg_class_t rclass)
-
- Like ``TARGET_PREFERRED_RELOAD_CLASS``, but for output reloads instead of
- input reloads.
-
- The default version of this hook always returns value of ``rclass``
- argument.
-
- You can also use ``TARGET_PREFERRED_OUTPUT_RELOAD_CLASS`` to discourage
- reload from using some alternatives, like ``TARGET_PREFERRED_RELOAD_CLASS``.
-
-[TARGET_PREFERRED_OUTPUT_RELOAD_CLASS]
-
-[TARGET_SELECT_EARLY_REMAT_MODES]
-.. function:: void TARGET_SELECT_EARLY_REMAT_MODES (sbitmap modes)
-
- On some targets, certain modes cannot be held in registers around a
- standard ABI call and are relatively expensive to spill to the stack.
- The early rematerialization pass can help in such cases by aggressively
- recomputing values after calls, so that they don't need to be spilled.
-
- This hook returns the set of such modes by setting the associated bits
- in :samp:`{modes}`. The default implementation selects no modes, which has
- the effect of disabling the early rematerialization pass.
-
-[TARGET_SELECT_EARLY_REMAT_MODES]
-
-[TARGET_CLASS_LIKELY_SPILLED_P]
-.. function:: bool TARGET_CLASS_LIKELY_SPILLED_P (reg_class_t rclass)
-
- A target hook which returns ``true`` if pseudos that have been assigned
- to registers of class :samp:`{rclass}` would likely be spilled because
- registers of :samp:`{rclass}` are needed for spill registers.
-
- The default version of this target hook returns ``true`` if :samp:`{rclass}`
- has exactly one register and ``false`` otherwise. On most machines, this
- default should be used. For generally register-starved machines, such as
- i386, or machines with right register constraints, such as SH, this hook
- can be used to avoid excessive spilling.
-
- This hook is also used by some of the global intra-procedural code
- transformations to throtle code motion, to avoid increasing register
- pressure.
-
-[TARGET_CLASS_LIKELY_SPILLED_P]
-
-[TARGET_CLASS_MAX_NREGS]
-.. function:: unsigned char TARGET_CLASS_MAX_NREGS (reg_class_t rclass, machine_mode mode)
-
- A target hook returns the maximum number of consecutive registers
- of class :samp:`{rclass}` needed to hold a value of mode :samp:`{mode}`.
-
- This is closely related to the macro ``TARGET_HARD_REGNO_NREGS``.
- In fact, the value returned by ``TARGET_CLASS_MAX_NREGS (rclass,
- mode)`` target hook should be the maximum value of
- ``TARGET_HARD_REGNO_NREGS (regno, mode)`` for all :samp:`{regno}`
- values in the class :samp:`{rclass}`.
-
- This target hook helps control the handling of multiple-word values
- in the reload pass.
-
- The default version of this target hook returns the size of :samp:`{mode}`
- in words.
-
-[TARGET_CLASS_MAX_NREGS]
-
-[TARGET_PREFERRED_RENAME_CLASS]
-.. function:: reg_class_t TARGET_PREFERRED_RENAME_CLASS (reg_class_t rclass)
-
- A target hook that places additional preference on the register
- class to use when it is necessary to rename a register in class
- :samp:`{rclass}` to another class, or perhaps :samp:`{NO_REGS}`, if no
- preferred register class is found or hook ``preferred_rename_class``
- is not implemented.
- Sometimes returning a more restrictive class makes better code. For
- example, on ARM, thumb-2 instructions using ``LO_REGS`` may be
- smaller than instructions using ``GENERIC_REGS``. By returning
- ``LO_REGS`` from ``preferred_rename_class``, code size can
- be reduced.
-
-[TARGET_PREFERRED_RENAME_CLASS]
-
-[TARGET_CANNOT_SUBSTITUTE_MEM_EQUIV_P]
-.. function:: bool TARGET_CANNOT_SUBSTITUTE_MEM_EQUIV_P (rtx subst)
-
- A target hook which returns ``true`` if :samp:`{subst}` can't
- substitute safely pseudos with equivalent memory values during
- register allocation.
- The default version of this target hook returns ``false``.
- On most machines, this default should be used. For generally
- machines with non orthogonal register usage for addressing, such
- as SH, this hook can be used to avoid excessive spilling.
-
-[TARGET_CANNOT_SUBSTITUTE_MEM_EQUIV_P]
-
-[TARGET_LEGITIMIZE_ADDRESS_DISPLACEMENT]
-.. function:: bool TARGET_LEGITIMIZE_ADDRESS_DISPLACEMENT (rtx *offset1, rtx *offset2, poly_int64 orig_offset, machine_mode mode)
-
- This hook tries to split address offset :samp:`{orig_offset}` into
- two parts: one that should be added to the base address to create
- a local anchor point, and an additional offset that can be applied
- to the anchor to address a value of mode :samp:`{mode}`. The idea is that
- the local anchor could be shared by other accesses to nearby locations.
-
- The hook returns true if it succeeds, storing the offset of the
- anchor from the base in :samp:`{offset1}` and the offset of the final address
- from the anchor in :samp:`{offset2}`. The default implementation returns false.
-
-[TARGET_LEGITIMIZE_ADDRESS_DISPLACEMENT]
-
-[TARGET_EXPAND_TO_RTL_HOOK]
-.. function:: void TARGET_EXPAND_TO_RTL_HOOK (void)
-
- This hook is called just before expansion into rtl, allowing the target
- to perform additional initializations or analysis before the expansion.
- For example, the rs6000 port uses it to allocate a scratch stack slot
- for use in copying SDmode values between memory and floating point
- registers whenever the function being expanded has any SDmode
- usage.
-
-[TARGET_EXPAND_TO_RTL_HOOK]
-
-[TARGET_INSTANTIATE_DECLS]
-.. function:: void TARGET_INSTANTIATE_DECLS (void)
-
- This hook allows the backend to perform additional instantiations on rtl
- that are not actually in any insns yet, but will be later.
-
-[TARGET_INSTANTIATE_DECLS]
-
-[TARGET_HARD_REGNO_NREGS]
-.. function:: unsigned int TARGET_HARD_REGNO_NREGS (unsigned int regno, machine_mode mode)
-
- This hook returns the number of consecutive hard registers, starting
- at register number :samp:`{regno}`, required to hold a value of mode
- :samp:`{mode}`. This hook must never return zero, even if a register
- cannot hold the requested mode - indicate that with
- ``TARGET_HARD_REGNO_MODE_OK`` and/or
- ``TARGET_CAN_CHANGE_MODE_CLASS`` instead.
-
- The default definition returns the number of words in :samp:`{mode}`.
-
-[TARGET_HARD_REGNO_NREGS]
-
-[TARGET_HARD_REGNO_MODE_OK]
-.. function:: bool TARGET_HARD_REGNO_MODE_OK (unsigned int regno, machine_mode mode)
-
- This hook returns true if it is permissible to store a value
- of mode :samp:`{mode}` in hard register number :samp:`{regno}` (or in several
- registers starting with that one). The default definition returns true
- unconditionally.
-
- You need not include code to check for the numbers of fixed registers,
- because the allocation mechanism considers them to be always occupied.
-
- .. index:: register pairs
-
- On some machines, double-precision values must be kept in even/odd
- register pairs. You can implement that by defining this hook to reject
- odd register numbers for such modes.
-
- The minimum requirement for a mode to be OK in a register is that the
- :samp:`mov{mode}` instruction pattern support moves between the
- register and other hard register in the same class and that moving a
- value into the register and back out not alter it.
-
- Since the same instruction used to move ``word_mode`` will work for
- all narrower integer modes, it is not necessary on any machine for
- this hook to distinguish between these modes, provided you define
- patterns :samp:`movhi`, etc., to take advantage of this. This is
- useful because of the interaction between ``TARGET_HARD_REGNO_MODE_OK``
- and ``TARGET_MODES_TIEABLE_P`` ; it is very desirable for all integer
- modes to be tieable.
-
- Many machines have special registers for floating point arithmetic.
- Often people assume that floating point machine modes are allowed only
- in floating point registers. This is not true. Any registers that
- can hold integers can safely *hold* a floating point machine
- mode, whether or not floating arithmetic can be done on it in those
- registers. Integer move instructions can be used to move the values.
-
- On some machines, though, the converse is true: fixed-point machine
- modes may not go in floating registers. This is true if the floating
- registers normalize any value stored in them, because storing a
- non-floating value there would garble it. In this case,
- ``TARGET_HARD_REGNO_MODE_OK`` should reject fixed-point machine modes in
- floating registers. But if the floating registers do not automatically
- normalize, if you can store any bit pattern in one and retrieve it
- unchanged without a trap, then any machine mode may go in a floating
- register, so you can define this hook to say so.
-
- The primary significance of special floating registers is rather that
- they are the registers acceptable in floating point arithmetic
- instructions. However, this is of no concern to
- ``TARGET_HARD_REGNO_MODE_OK``. You handle it by writing the proper
- constraints for those instructions.
-
- On some machines, the floating registers are especially slow to access,
- so that it is better to store a value in a stack frame than in such a
- register if floating point arithmetic is not being done. As long as the
- floating registers are not in class ``GENERAL_REGS``, they will not
- be used unless some pattern's constraint asks for one.
-
-[TARGET_HARD_REGNO_MODE_OK]
-
-[TARGET_MODES_TIEABLE_P]
-.. function:: bool TARGET_MODES_TIEABLE_P (machine_mode mode1, machine_mode mode2)
-
- This hook returns true if a value of mode :samp:`{mode1}` is accessible
- in mode :samp:`{mode2}` without copying.
-
- If ``TARGET_HARD_REGNO_MODE_OK (r, mode1)`` and
- ``TARGET_HARD_REGNO_MODE_OK (r, mode2)`` are always
- the same for any :samp:`{r}`, then
- ``TARGET_MODES_TIEABLE_P (mode1, mode2)``
- should be true. If they differ for any :samp:`{r}`, you should define
- this hook to return false unless some other mechanism ensures the
- accessibility of the value in a narrower mode.
-
- You should define this hook to return true in as many cases as
- possible since doing so will allow GCC to perform better register
- allocation. The default definition returns true unconditionally.
-
-[TARGET_MODES_TIEABLE_P]
-
-[TARGET_HARD_REGNO_SCRATCH_OK]
-.. function:: bool TARGET_HARD_REGNO_SCRATCH_OK (unsigned int regno)
-
- This target hook should return ``true`` if it is OK to use a hard register
- :samp:`{regno}` as scratch reg in peephole2.
-
- One common use of this macro is to prevent using of a register that
- is not saved by a prologue in an interrupt handler.
-
- The default version of this hook always returns ``true``.
-
-[TARGET_HARD_REGNO_SCRATCH_OK]
-
-[TARGET_HARD_REGNO_CALL_PART_CLOBBERED]
-.. function:: bool TARGET_HARD_REGNO_CALL_PART_CLOBBERED (unsigned int abi_id, unsigned int regno, machine_mode mode)
-
- ABIs usually specify that calls must preserve the full contents
- of a particular register, or that calls can alter any part of a
- particular register. This information is captured by the target macro
- ``CALL_REALLY_USED_REGISTERS``. However, some ABIs specify that calls
- must preserve certain bits of a particular register but can alter others.
- This hook should return true if this applies to at least one of the
- registers in :samp:`(reg:{mode}{regno})`, and if as a result the
- call would alter part of the :samp:`{mode}` value. For example, if a call
- preserves the low 32 bits of a 64-bit hard register :samp:`{regno}` but can
- clobber the upper 32 bits, this hook should return true for a 64-bit mode
- but false for a 32-bit mode.
-
- The value of :samp:`{abi_id}` comes from the ``predefined_function_abi``
- structure that describes the ABI of the call; see the definition of the
- structure for more details. If (as is usual) the target uses the same ABI
- for all functions in a translation unit, :samp:`{abi_id}` is always 0.
-
- The default implementation returns false, which is correct
- for targets that don't have partly call-clobbered registers.
-
-[TARGET_HARD_REGNO_CALL_PART_CLOBBERED]
-
-[TARGET_GET_MULTILIB_ABI_NAME]
-.. function:: const char * TARGET_GET_MULTILIB_ABI_NAME (void)
-
- This hook returns name of multilib ABI name.
-
-[TARGET_GET_MULTILIB_ABI_NAME]
-
-[TARGET_CASE_VALUES_THRESHOLD]
-.. function:: unsigned int TARGET_CASE_VALUES_THRESHOLD (void)
-
- This function return the smallest number of different values for which it
- is best to use a jump-table instead of a tree of conditional branches.
- The default is four for machines with a ``casesi`` instruction and
- five otherwise. This is best for most machines.
-
-[TARGET_CASE_VALUES_THRESHOLD]
-
-[TARGET_STARTING_FRAME_OFFSET]
-.. function:: HOST_WIDE_INT TARGET_STARTING_FRAME_OFFSET (void)
-
- This hook returns the offset from the frame pointer to the first local
- variable slot to be allocated. If ``FRAME_GROWS_DOWNWARD``, it is the
- offset to *end* of the first slot allocated, otherwise it is the
- offset to *beginning* of the first slot allocated. The default
- implementation returns 0.
-
-[TARGET_STARTING_FRAME_OFFSET]
-
-[TARGET_COMPUTE_FRAME_LAYOUT]
-.. function:: void TARGET_COMPUTE_FRAME_LAYOUT (void)
-
- This target hook is called once each time the frame layout needs to be
- recalculated. The calculations can be cached by the target and can then
- be used by ``INITIAL_ELIMINATION_OFFSET`` instead of re-computing the
- layout on every invocation of that hook. This is particularly useful
- for targets that have an expensive frame layout function. Implementing
- this callback is optional.
-
-[TARGET_COMPUTE_FRAME_LAYOUT]
-
-[TARGET_FRAME_POINTER_REQUIRED]
-.. function:: bool TARGET_FRAME_POINTER_REQUIRED (void)
-
- This target hook should return ``true`` if a function must have and use
- a frame pointer. This target hook is called in the reload pass. If its return
- value is ``true`` the function will have a frame pointer.
-
- This target hook can in principle examine the current function and decide
- according to the facts, but on most machines the constant ``false`` or the
- constant ``true`` suffices. Use ``false`` when the machine allows code
- to be generated with no frame pointer, and doing so saves some time or space.
- Use ``true`` when there is no possible advantage to avoiding a frame
- pointer.
-
- In certain cases, the compiler does not know how to produce valid code
- without a frame pointer. The compiler recognizes those cases and
- automatically gives the function a frame pointer regardless of what
- ``targetm.frame_pointer_required`` returns. You don't need to worry about
- them.
-
- In a function that does not require a frame pointer, the frame pointer
- register can be allocated for ordinary usage, unless you mark it as a
- fixed register. See ``FIXED_REGISTERS`` for more information.
-
- Default return value is ``false``.
-
-[TARGET_FRAME_POINTER_REQUIRED]
-
-[TARGET_CAN_ELIMINATE]
-.. function:: bool TARGET_CAN_ELIMINATE (const int from_reg, const int to_reg)
-
- This target hook should return ``true`` if the compiler is allowed to
- try to replace register number :samp:`{from_reg}` with register number
- :samp:`{to_reg}`. This target hook will usually be ``true``, since most of the
- cases preventing register elimination are things that the compiler already
- knows about.
-
- Default return value is ``true``.
-
-[TARGET_CAN_ELIMINATE]
-
-[TARGET_CONDITIONAL_REGISTER_USAGE]
-.. function:: void TARGET_CONDITIONAL_REGISTER_USAGE (void)
-
- This hook may conditionally modify five variables
- ``fixed_regs``, ``call_used_regs``, ``global_regs``,
- ``reg_names``, and ``reg_class_contents``, to take into account
- any dependence of these register sets on target flags. The first three
- of these are of type ``char []`` (interpreted as boolean vectors).
- ``global_regs`` is a ``const char *[]``, and
- ``reg_class_contents`` is a ``HARD_REG_SET``. Before the macro is
- called, ``fixed_regs``, ``call_used_regs``,
- ``reg_class_contents``, and ``reg_names`` have been initialized
- from ``FIXED_REGISTERS``, ``CALL_USED_REGISTERS``,
- ``REG_CLASS_CONTENTS``, and ``REGISTER_NAMES``, respectively.
- ``global_regs`` has been cleared, and any :option:`-ffixed-reg`,
- :option:`-fcall-used-reg` and :option:`-fcall-saved-reg`
- command options have been applied.
-
- .. index:: disabling certain registers, controlling register usage
-
- If the usage of an entire class of registers depends on the target
- flags, you may indicate this to GCC by using this macro to modify
- ``fixed_regs`` and ``call_used_regs`` to 1 for each of the
- registers in the classes which should not be used by GCC. Also make
- ``define_register_constraint`` s return ``NO_REGS`` for constraints
- that shouldn't be used.
-
- (However, if this class is not included in ``GENERAL_REGS`` and all
- of the insn patterns whose constraints permit this class are
- controlled by target switches, then GCC will automatically avoid using
- these registers when the target switches are opposed to them.)
-
-[TARGET_CONDITIONAL_REGISTER_USAGE]
-
-[TARGET_STACK_CLASH_PROTECTION_ALLOCA_PROBE_RANGE]
-.. function:: HOST_WIDE_INT TARGET_STACK_CLASH_PROTECTION_ALLOCA_PROBE_RANGE (void)
-
- Some targets have an ABI defined interval for which no probing needs to be done.
- When a probe does need to be done this same interval is used as the probe distance
- up when doing stack clash protection for alloca.
- On such targets this value can be set to override the default probing up interval.
- 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.
- You need not define this macro if it would always have the value zero.
-
-[TARGET_STACK_CLASH_PROTECTION_ALLOCA_PROBE_RANGE]
-
-[TARGET_C_EXCESS_PRECISION]
-.. function:: enum flt_eval_method TARGET_C_EXCESS_PRECISION (enum excess_precision_type type)
-
- Return a value, with the same meaning as the C99 macro
- ``FLT_EVAL_METHOD`` that describes which excess precision should be
- applied. :samp:`{type}` is either ``EXCESS_PRECISION_TYPE_IMPLICIT``,
- ``EXCESS_PRECISION_TYPE_FAST``,
- ``EXCESS_PRECISION_TYPE_STANDARD``, or
- ``EXCESS_PRECISION_TYPE_FLOAT16``. For
- ``EXCESS_PRECISION_TYPE_IMPLICIT``, the target should return which
- precision and range operations will be implictly evaluated in regardless
- of the excess precision explicitly added. For
- ``EXCESS_PRECISION_TYPE_STANDARD``,
- ``EXCESS_PRECISION_TYPE_FLOAT16``, and
- ``EXCESS_PRECISION_TYPE_FAST``, the target should return the
- explicit excess precision that should be added depending on the
- value set for :option:`-fexcess-precision=[standard|fast|16]`.
- Note that unpredictable explicit excess precision does not make sense,
- so a target should never return ``FLT_EVAL_METHOD_UNPREDICTABLE``
- when :samp:`{type}` is ``EXCESS_PRECISION_TYPE_STANDARD``,
- ``EXCESS_PRECISION_TYPE_FLOAT16`` or
- ``EXCESS_PRECISION_TYPE_FAST``.
-
- Return a value, with the same meaning as the C99 macro
- ``FLT_EVAL_METHOD`` that describes which excess precision should be
- applied.
-
-[TARGET_C_EXCESS_PRECISION]
-
-[TARGET_CXX_GUARD_TYPE]
-.. function:: tree TARGET_CXX_GUARD_TYPE (void)
-
- Define this hook to override the integer type used for guard variables.
- These are used to implement one-time construction of static objects. The
- default is long_long_integer_type_node.
-
-[TARGET_CXX_GUARD_TYPE]
-
-[TARGET_CXX_GUARD_MASK_BIT]
-.. function:: bool TARGET_CXX_GUARD_MASK_BIT (void)
-
- This hook determines how guard variables are used. It should return
- ``false`` (the default) if the first byte should be used. A return value of
- ``true`` indicates that only the least significant bit should be used.
-
-[TARGET_CXX_GUARD_MASK_BIT]
-
-[TARGET_CXX_GET_COOKIE_SIZE]
-.. function:: tree TARGET_CXX_GET_COOKIE_SIZE (tree type)
-
- This hook returns the size of the cookie to use when allocating an array
- whose elements have the indicated :samp:`{type}`. Assumes that it is already
- known that a cookie is needed. The default is
- ``max(sizeof (size_t), alignof(type))``, as defined in section 2.7 of the
- IA64/Generic C++ ABI.
-
-[TARGET_CXX_GET_COOKIE_SIZE]
-
-[TARGET_CXX_COOKIE_HAS_SIZE]
-.. function:: bool TARGET_CXX_COOKIE_HAS_SIZE (void)
-
- This hook should return ``true`` if the element size should be stored in
- array cookies. The default is to return ``false``.
-
-[TARGET_CXX_COOKIE_HAS_SIZE]
-
-[TARGET_CXX_IMPORT_EXPORT_CLASS]
-.. function:: int TARGET_CXX_IMPORT_EXPORT_CLASS (tree type, int import_export)
-
- If defined by a backend this hook allows the decision made to export
- class :samp:`{type}` to be overruled. Upon entry :samp:`{import_export}`
- will contain 1 if the class is going to be exported, -1 if it is going
- to be imported and 0 otherwise. This function should return the
- modified value and perform any other actions necessary to support the
- backend's targeted operating system.
-
-[TARGET_CXX_IMPORT_EXPORT_CLASS]
-
-[TARGET_CXX_CDTOR_RETURNS_THIS]
-.. function:: bool TARGET_CXX_CDTOR_RETURNS_THIS (void)
-
- This hook should return ``true`` if constructors and destructors return
- the address of the object created/destroyed. The default is to return
- ``false``.
-
-[TARGET_CXX_CDTOR_RETURNS_THIS]
-
-[TARGET_CXX_KEY_METHOD_MAY_BE_INLINE]
-.. function:: bool TARGET_CXX_KEY_METHOD_MAY_BE_INLINE (void)
-
- This hook returns true if the key method for a class (i.e., the method
- which, if defined in the current translation unit, causes the virtual
- table to be emitted) may be an inline function. Under the standard
- Itanium C++ ABI the key method may be an inline function so long as
- the function is not declared inline in the class definition. Under
- some variants of the ABI, an inline function can never be the key
- method. The default is to return ``true``.
-
-[TARGET_CXX_KEY_METHOD_MAY_BE_INLINE]
-
-[TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY]
-.. function:: void TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY (tree decl)
-
- :samp:`{decl}` is a virtual table, virtual table table, typeinfo object,
- or other similar implicit class data object that will be emitted with
- external linkage in this translation unit. No ELF visibility has been
- explicitly specified. If the target needs to specify a visibility
- other than that of the containing class, use this hook to set
- ``DECL_VISIBILITY`` and ``DECL_VISIBILITY_SPECIFIED``.
-
-[TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY]
-
-[TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT]
-.. function:: bool TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT (void)
-
- This hook returns true (the default) if virtual tables and other
- similar implicit class data objects are always COMDAT if they have
- external linkage. If this hook returns false, then class data for
- classes whose virtual table will be emitted in only one translation
- unit will not be COMDAT.
-
-[TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT]
-
-[TARGET_CXX_LIBRARY_RTTI_COMDAT]
-.. function:: bool TARGET_CXX_LIBRARY_RTTI_COMDAT (void)
-
- This hook returns true (the default) if the RTTI information for
- the basic types which is defined in the C++ runtime should always
- be COMDAT, false if it should not be COMDAT.
-
-[TARGET_CXX_LIBRARY_RTTI_COMDAT]
-
-[TARGET_CXX_USE_AEABI_ATEXIT]
-.. function:: bool TARGET_CXX_USE_AEABI_ATEXIT (void)
-
- This hook returns true if ``__aeabi_atexit`` (as defined by the ARM EABI)
- should be used to register static destructors when :option:`-fuse-cxa-atexit`
- is in effect. The default is to return false to use ``__cxa_atexit``.
-
-[TARGET_CXX_USE_AEABI_ATEXIT]
-
-[TARGET_CXX_USE_ATEXIT_FOR_CXA_ATEXIT]
-.. function:: bool TARGET_CXX_USE_ATEXIT_FOR_CXA_ATEXIT (void)
-
- This hook returns true if the target ``atexit`` function can be used
- in the same manner as ``__cxa_atexit`` to register C++ static
- destructors. This requires that ``atexit`` -registered functions in
- shared libraries are run in the correct order when the libraries are
- unloaded. The default is to return false.
-
-[TARGET_CXX_USE_ATEXIT_FOR_CXA_ATEXIT]
-
-[TARGET_CXX_ADJUST_CLASS_AT_DEFINITION]
-.. function:: void TARGET_CXX_ADJUST_CLASS_AT_DEFINITION (tree type)
-
- :samp:`{type}` is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just
- been defined. Use this hook to make adjustments to the class (eg, tweak
- visibility or perform any other required target modifications).
-
-[TARGET_CXX_ADJUST_CLASS_AT_DEFINITION]
-
-[TARGET_CXX_DECL_MANGLING_CONTEXT]
-.. function:: tree TARGET_CXX_DECL_MANGLING_CONTEXT (const_tree decl)
-
- Return target-specific mangling context of :samp:`{decl}` or ``NULL_TREE``.
-
-[TARGET_CXX_DECL_MANGLING_CONTEXT]
-
-[TARGET_EMUTLS_GET_ADDRESS]
-.. c:var:: const char * TARGET_EMUTLS_GET_ADDRESS
-
- Contains the name of the helper function that uses a TLS control
- object to locate a TLS instance. The default causes libgcc's
- emulated TLS helper function to be used.
-
-[TARGET_EMUTLS_GET_ADDRESS]
-
-[TARGET_EMUTLS_REGISTER_COMMON]
-.. c:var:: const char * TARGET_EMUTLS_REGISTER_COMMON
-
- Contains the name of the helper function that should be used at
- program startup to register TLS objects that are implicitly
- initialized to zero. If this is ``NULL``, all TLS objects will
- have explicit initializers. The default causes libgcc's emulated TLS
- registration function to be used.
-
-[TARGET_EMUTLS_REGISTER_COMMON]
-
-[TARGET_EMUTLS_VAR_SECTION]
-.. c:var:: const char * TARGET_EMUTLS_VAR_SECTION
-
- Contains the name of the section in which TLS control variables should
- be placed. The default of ``NULL`` allows these to be placed in
- any section.
-
-[TARGET_EMUTLS_VAR_SECTION]
-
-[TARGET_EMUTLS_TMPL_SECTION]
-.. c:var:: const char * TARGET_EMUTLS_TMPL_SECTION
-
- Contains the name of the section in which TLS initializers should be
- placed. The default of ``NULL`` allows these to be placed in any
- section.
-
-[TARGET_EMUTLS_TMPL_SECTION]
-
-[TARGET_EMUTLS_VAR_PREFIX]
-.. c:var:: const char * TARGET_EMUTLS_VAR_PREFIX
-
- Contains the prefix to be prepended to TLS control variable names.
- The default of ``NULL`` uses a target-specific prefix.
-
-[TARGET_EMUTLS_VAR_PREFIX]
-
-[TARGET_EMUTLS_TMPL_PREFIX]
-.. c:var:: const char * TARGET_EMUTLS_TMPL_PREFIX
-
- Contains the prefix to be prepended to TLS initializer objects. The
- default of ``NULL`` uses a target-specific prefix.
-
-[TARGET_EMUTLS_TMPL_PREFIX]
-
-[TARGET_EMUTLS_VAR_FIELDS]
-.. function:: tree TARGET_EMUTLS_VAR_FIELDS (tree type, tree *name)
-
- Specifies a function that generates the FIELD_DECLs for a TLS control
- object type. :samp:`{type}` is the RECORD_TYPE the fields are for and
- :samp:`{name}` should be filled with the structure tag, if the default of
- ``__emutls_object`` is unsuitable. The default creates a type suitable
- for libgcc's emulated TLS function.
-
-[TARGET_EMUTLS_VAR_FIELDS]
-
-[TARGET_EMUTLS_VAR_INIT]
-.. function:: tree TARGET_EMUTLS_VAR_INIT (tree var, tree decl, tree tmpl_addr)
-
- Specifies a function that generates the CONSTRUCTOR to initialize a
- TLS control object. :samp:`{var}` is the TLS control object, :samp:`{decl}`
- is the TLS object and :samp:`{tmpl_addr}` is the address of the
- initializer. The default initializes libgcc's emulated TLS control object.
-
-[TARGET_EMUTLS_VAR_INIT]
-
-[TARGET_EMUTLS_VAR_ALIGN_FIXED]
-.. c:var:: bool TARGET_EMUTLS_VAR_ALIGN_FIXED
-
- Specifies whether the alignment of TLS control variable objects is
- fixed and should not be increased as some backends may do to optimize
- single objects. The default is false.
-
-[TARGET_EMUTLS_VAR_ALIGN_FIXED]
-
-[TARGET_EMUTLS_DEBUG_FORM_TLS_ADDRESS]
-.. c:var:: bool TARGET_EMUTLS_DEBUG_FORM_TLS_ADDRESS
-
- Specifies whether a DWARF ``DW_OP_form_tls_address`` location descriptor
- may be used to describe emulated TLS control objects.
-
-[TARGET_EMUTLS_DEBUG_FORM_TLS_ADDRESS]
-
-[TARGET_OPTION_VALID_ATTRIBUTE_P]
-.. function:: bool TARGET_OPTION_VALID_ATTRIBUTE_P (tree fndecl, tree name, tree args, int flags)
-
- This hook is called to parse ``attribute(target("..."))``, which
- allows setting target-specific options on individual functions.
- These function-specific options may differ
- from the options specified on the command line. The hook should return
- ``true`` if the options are valid.
-
- The hook should set the ``DECL_FUNCTION_SPECIFIC_TARGET`` field in
- the function declaration to hold a pointer to a target-specific
- ``struct cl_target_option`` structure.
-
-[TARGET_OPTION_VALID_ATTRIBUTE_P]
-
-[TARGET_OPTION_SAVE]
-.. function:: void TARGET_OPTION_SAVE (struct cl_target_option *ptr, struct gcc_options *opts, struct gcc_options *opts_set)
-
- This hook is called to save any additional target-specific information
- in the ``struct cl_target_option`` structure for function-specific
- options from the ``struct gcc_options`` structure.
- See :ref:`option-file-format`.
-
-[TARGET_OPTION_SAVE]
-
-[TARGET_OPTION_RESTORE]
-.. function:: void TARGET_OPTION_RESTORE (struct gcc_options *opts, struct gcc_options *opts_set, struct cl_target_option *ptr)
-
- This hook is called to restore any additional target-specific
- information in the ``struct cl_target_option`` structure for
- function-specific options to the ``struct gcc_options`` structure.
-
-[TARGET_OPTION_RESTORE]
-
-[TARGET_OPTION_POST_STREAM_IN]
-.. function:: void TARGET_OPTION_POST_STREAM_IN (struct cl_target_option *ptr)
-
- This hook is called to update target-specific information in the
- ``struct cl_target_option`` structure after it is streamed in from
- LTO bytecode.
-
-[TARGET_OPTION_POST_STREAM_IN]
-
-[TARGET_OPTION_PRINT]
-.. function:: void TARGET_OPTION_PRINT (FILE *file, int indent, struct cl_target_option *ptr)
-
- This hook is called to print any additional target-specific
- information in the ``struct cl_target_option`` structure for
- function-specific options.
-
-[TARGET_OPTION_PRINT]
-
-[TARGET_OPTION_PRAGMA_PARSE]
-.. function:: bool TARGET_OPTION_PRAGMA_PARSE (tree args, tree pop_target)
-
- This target hook parses the options for ``#pragma GCC target``, which
- sets the target-specific options for functions that occur later in the
- input stream. The options accepted should be the same as those handled by the
- ``TARGET_OPTION_VALID_ATTRIBUTE_P`` hook.
-
-[TARGET_OPTION_PRAGMA_PARSE]
-
-[TARGET_OPTION_OVERRIDE]
-.. function:: void TARGET_OPTION_OVERRIDE (void)
-
- Sometimes certain combinations of command options do not make sense on
- a particular target machine. You can override the hook
- ``TARGET_OPTION_OVERRIDE`` to take account of this. This hooks is called
- once just after all the command options have been parsed.
-
- Don't use this hook to turn on various extra optimizations for
- :option:`-O`. That is what ``TARGET_OPTION_OPTIMIZATION`` is for.
-
- If you need to do something whenever the optimization level is
- changed via the optimize attribute or pragma, see
- ``TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE``
-
-[TARGET_OPTION_OVERRIDE]
-
-[TARGET_OPTION_FUNCTION_VERSIONS]
-.. function:: bool TARGET_OPTION_FUNCTION_VERSIONS (tree decl1, tree decl2)
-
- This target hook returns ``true`` if :samp:`{DECL1}` and :samp:`{DECL2}` are
- versions of the same function. :samp:`{DECL1}` and :samp:`{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.
-
-[TARGET_OPTION_FUNCTION_VERSIONS]
-
-[TARGET_CAN_INLINE_P]
-.. function:: bool TARGET_CAN_INLINE_P (tree caller, tree callee)
-
- This target hook returns ``false`` if the :samp:`{caller}` function
- cannot inline :samp:`{callee}`, based on target specific information. By
- default, inlining is not allowed if the callee function has function
- specific target options and the caller does not use the same options.
-
-[TARGET_CAN_INLINE_P]
-
-[TARGET_UPDATE_IPA_FN_TARGET_INFO]
-.. function:: bool TARGET_UPDATE_IPA_FN_TARGET_INFO (unsigned int& info, const gimple* stmt)
-
- Allow target to analyze all gimple statements for the given function to
- record and update some target specific information for inlining. A typical
- example is that a caller with one isa feature disabled is normally not
- allowed to inline a callee with that same isa feature enabled even which is
- attributed by always_inline, but with the conservative analysis on all
- statements of the callee if we are able to guarantee the callee does not
- exploit any instructions from the mismatch isa feature, it would be safe to
- allow the caller to inline the callee.
- :samp:`{info}` is one ``unsigned int`` value to record information in which
- one set bit indicates one corresponding feature is detected in the analysis,
- :samp:`{stmt}` is the statement being analyzed. Return true if target still
- need to analyze the subsequent statements, otherwise return false to stop
- subsequent analysis.
- The default version of this hook returns false.
-
-[TARGET_UPDATE_IPA_FN_TARGET_INFO]
-
-[TARGET_NEED_IPA_FN_TARGET_INFO]
-.. function:: bool TARGET_NEED_IPA_FN_TARGET_INFO (const_tree decl, unsigned int& info)
-
- Allow target to check early whether it is necessary to analyze all gimple
- statements in the given function to update target specific information for
- inlining. See hook ``update_ipa_fn_target_info`` for usage example of
- target specific information. This hook is expected to be invoked ahead of
- the iterating with hook ``update_ipa_fn_target_info``.
- :samp:`{decl}` is the function being analyzed, :samp:`{info}` is the same as what
- in hook ``update_ipa_fn_target_info``, target can do one time update
- into :samp:`{info}` without iterating for some case. Return true if target
- decides to analyze all gimple statements to collect information, otherwise
- return false.
- The default version of this hook returns false.
-
-[TARGET_NEED_IPA_FN_TARGET_INFO]
-
-[TARGET_RELAYOUT_FUNCTION]
-.. function:: void TARGET_RELAYOUT_FUNCTION (tree fndecl)
-
- This target hook fixes function :samp:`{fndecl}` after attributes are processed.
- Default does nothing. On ARM, the default function's alignment is updated
- with the attribute target.
-
-[TARGET_RELAYOUT_FUNCTION]
-
-[TARGET_EXTRA_LIVE_ON_ENTRY]
-.. function:: void TARGET_EXTRA_LIVE_ON_ENTRY (bitmap regs)
-
- Add any hard registers to :samp:`{regs}` that are live on entry to the
- function. This hook only needs to be defined to provide registers that
- cannot be found by examination of FUNCTION_ARG_REGNO_P, the callee saved
- registers, STATIC_CHAIN_INCOMING_REGNUM, STATIC_CHAIN_REGNUM,
- TARGET_STRUCT_VALUE_RTX, FRAME_POINTER_REGNUM, EH_USES,
- FRAME_POINTER_REGNUM, ARG_POINTER_REGNUM, and the PIC_OFFSET_TABLE_REGNUM.
-
-[TARGET_EXTRA_LIVE_ON_ENTRY]
-
-[TARGET_CALL_FUSAGE_CONTAINS_NON_CALLEE_CLOBBERS]
-.. c:var:: bool TARGET_CALL_FUSAGE_CONTAINS_NON_CALLEE_CLOBBERS
-
- Set to true if each call that binds to a local definition explicitly
- clobbers or sets all non-fixed registers modified by performing the call.
- That is, by the call pattern itself, or by code that might be inserted by the
- linker (e.g. stubs, veneers, branch islands), but not including those
- modifiable by the callee. The affected registers may be mentioned explicitly
- in the call pattern, or included as clobbers in CALL_INSN_FUNCTION_USAGE.
- The default version of this hook is set to false. The purpose of this hook
- is to enable the fipa-ra optimization.
-
-[TARGET_CALL_FUSAGE_CONTAINS_NON_CALLEE_CLOBBERS]
-
-[TARGET_SET_UP_BY_PROLOGUE]
-.. function:: void TARGET_SET_UP_BY_PROLOGUE (struct hard_reg_set_container *)
-
- This hook should add additional registers that are computed by the prologue
- to the hard regset for shrink-wrapping optimization purposes.
-
-[TARGET_SET_UP_BY_PROLOGUE]
-
-[TARGET_WARN_FUNC_RETURN]
-.. function:: bool TARGET_WARN_FUNC_RETURN (tree)
-
- True if a function's return statements should be checked for matching
- the function's return type. This includes checking for falling off the end
- of a non-void function. Return false if no such check should be made.
-
-[TARGET_WARN_FUNC_RETURN]
-
-[TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS]
-.. function:: sbitmap TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS (void)
-
- This hook should return an ``sbitmap`` with the bits set for those
- components that can be separately shrink-wrapped in the current function.
- Return ``NULL`` if the current function should not get any separate
- shrink-wrapping.
- Don't define this hook if it would always return ``NULL``.
- If it is defined, the other hooks in this group have to be defined as well.
-
-[TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS]
-
-[TARGET_SHRINK_WRAP_COMPONENTS_FOR_BB]
-.. function:: sbitmap TARGET_SHRINK_WRAP_COMPONENTS_FOR_BB (basic_block)
-
- This hook should return an ``sbitmap`` with the bits set for those
- components where either the prologue component has to be executed before
- the ``basic_block``, or the epilogue component after it, or both.
-
-[TARGET_SHRINK_WRAP_COMPONENTS_FOR_BB]
-
-[TARGET_SHRINK_WRAP_DISQUALIFY_COMPONENTS]
-.. function:: void TARGET_SHRINK_WRAP_DISQUALIFY_COMPONENTS (sbitmap components, edge e, sbitmap edge_components, bool is_prologue)
-
- This hook should clear the bits in the :samp:`{components}` bitmap for those
- components in :samp:`{edge_components}` that the target cannot handle on edge
- :samp:`{e}`, where :samp:`{is_prologue}` says if this is for a prologue or an
- epilogue instead.
-
-[TARGET_SHRINK_WRAP_DISQUALIFY_COMPONENTS]
-
-[TARGET_SHRINK_WRAP_EMIT_PROLOGUE_COMPONENTS]
-.. function:: void TARGET_SHRINK_WRAP_EMIT_PROLOGUE_COMPONENTS (sbitmap)
-
- Emit prologue insns for the components indicated by the parameter.
-
-[TARGET_SHRINK_WRAP_EMIT_PROLOGUE_COMPONENTS]
-
-[TARGET_SHRINK_WRAP_EMIT_EPILOGUE_COMPONENTS]
-.. function:: void TARGET_SHRINK_WRAP_EMIT_EPILOGUE_COMPONENTS (sbitmap)
-
- Emit epilogue insns for the components indicated by the parameter.
-
-[TARGET_SHRINK_WRAP_EMIT_EPILOGUE_COMPONENTS]
-
-[TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS]
-.. function:: void TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS (sbitmap)
-
- Mark the components in the parameter as handled, so that the
- ``prologue`` and ``epilogue`` named patterns know to ignore those
- components. The target code should not hang on to the ``sbitmap``, it
- will be deleted after this call.
-
-[TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS]
-
-[TARGET_DEBUG_UNWIND_INFO]
-.. function:: enum unwind_info_type TARGET_DEBUG_UNWIND_INFO (void)
-
- This hook defines the mechanism that will be used for describing frame
- unwind information to the debugger. Normally the hook will return
- ``UI_DWARF2`` if DWARF 2 debug information is enabled, and
- return ``UI_NONE`` otherwise.
-
- A target may return ``UI_DWARF2`` even when DWARF 2 debug information
- is disabled in order to always output DWARF 2 frame information.
-
- A target may return ``UI_TARGET`` if it has ABI specified unwind tables.
- This will suppress generation of the normal debug frame unwind information.
-
-[TARGET_DEBUG_UNWIND_INFO]
-
-[TARGET_RESET_LOCATION_VIEW]
-.. function:: int TARGET_RESET_LOCATION_VIEW (rtx_insn *)
-
- This hook, if defined, enables -ginternal-reset-location-views, and
- uses its result to override cases in which the estimated min insn
- length might be nonzero even when a PC advance (i.e., a view reset)
- cannot be taken for granted.
-
- If the hook is defined, it must return a positive value to indicate
- the insn definitely advances the PC, and so the view number can be
- safely assumed to be reset; a negative value to mean the insn
- definitely does not advance the PC, and os the view number must not
- be reset; or zero to decide based on the estimated insn length.
-
- If insn length is to be regarded as reliable, set the hook to
- ``hook_int_rtx_insn_0``.
-
-[TARGET_RESET_LOCATION_VIEW]
-
-[TARGET_CANONICALIZE_COMPARISON]
-.. function:: void TARGET_CANONICALIZE_COMPARISON (int *code, rtx *op0, rtx *op1, bool op0_preserve_value)
-
- On some machines not all possible comparisons are defined, but you can
- convert an invalid comparison into a valid one. For example, the Alpha
- does not have a ``GT`` comparison, but you can use an ``LT``
- comparison instead and swap the order of the operands.
-
- On such machines, implement this hook to do any required conversions.
- :samp:`{code}` is the initial comparison code and :samp:`{op0}` and :samp:`{op1}`
- are the left and right operands of the comparison, respectively. If
- :samp:`{op0_preserve_value}` is ``true`` the implementation is not
- allowed to change the value of :samp:`{op0}` since the value might be used
- in RTXs which aren't comparisons. E.g. the implementation is not
- allowed to swap operands in that case.
-
- GCC will not assume that the comparison resulting from this macro is
- valid but will see if the resulting insn matches a pattern in the
- :samp:`md` file.
-
- You need not to implement this hook if it would never change the
- comparison code or operands.
-
-[TARGET_CANONICALIZE_COMPARISON]
-
-[TARGET_MIN_ARITHMETIC_PRECISION]
-.. function:: unsigned int TARGET_MIN_ARITHMETIC_PRECISION (void)
-
- On some RISC architectures with 64-bit registers, the processor also
- maintains 32-bit condition codes that make it possible to do real 32-bit
- arithmetic, although the operations are performed on the full registers.
-
- On such architectures, defining this hook to 32 tells the compiler to try
- using 32-bit arithmetical operations setting the condition codes instead
- of doing full 64-bit arithmetic.
-
- More generally, define this hook on RISC architectures if you want the
- compiler to try using arithmetical operations setting the condition codes
- with a precision lower than the word precision.
-
- You need not define this hook if ``WORD_REGISTER_OPERATIONS`` is not
- defined to 1.
-
-[TARGET_MIN_ARITHMETIC_PRECISION]
-
-[TARGET_ATOMIC_TEST_AND_SET_TRUEVAL]
-.. c:var:: unsigned char TARGET_ATOMIC_TEST_AND_SET_TRUEVAL
-
- This value should be set if the result written by
- ``atomic_test_and_set`` is not exactly 1, i.e. the
- ``bool`` ``true``.
-
-[TARGET_ATOMIC_TEST_AND_SET_TRUEVAL]
-
-[TARGET_ATOMIC_ALIGN_FOR_MODE]
-.. function:: unsigned int TARGET_ATOMIC_ALIGN_FOR_MODE (machine_mode mode)
-
- If defined, this function returns an appropriate alignment in bits for an
- atomic object of machine_mode :samp:`{mode}`. If 0 is returned then the
- default alignment for the specified mode is used.
-
-[TARGET_ATOMIC_ALIGN_FOR_MODE]
-
-[TARGET_ATOMIC_ASSIGN_EXPAND_FENV]
-.. function:: void TARGET_ATOMIC_ASSIGN_EXPAND_FENV (tree *hold, tree *clear, tree *update)
-
- ISO C11 requires atomic compound assignments that may raise floating-point
- exceptions to raise exceptions corresponding to the arithmetic operation
- whose result was successfully stored in a compare-and-exchange sequence.
- This requires code equivalent to calls to ``feholdexcept``,
- ``feclearexcept`` and ``feupdateenv`` to be generated at
- appropriate points in the compare-and-exchange sequence. This hook should
- set ``*hold`` to an expression equivalent to the call to
- ``feholdexcept``, ``*clear`` to an expression equivalent to
- the call to ``feclearexcept`` and ``*update`` to an expression
- equivalent to the call to ``feupdateenv``. The three expressions are
- ``NULL_TREE`` on entry to the hook and may be left as ``NULL_TREE``
- if no code is required in a particular place. The default implementation
- leaves all three expressions as ``NULL_TREE``. The
- ``__atomic_feraiseexcept`` function from ``libatomic`` may be of use
- as part of the code generated in ``*update``.
-
-[TARGET_ATOMIC_ASSIGN_EXPAND_FENV]
-
-[TARGET_HAVE_SWITCHABLE_BSS_SECTIONS]
-.. c:var:: bool TARGET_HAVE_SWITCHABLE_BSS_SECTIONS
-
- This flag is true if we can create zeroed data by switching to a BSS
- section and then using ``ASM_OUTPUT_SKIP`` to allocate the space.
- This is true on most ELF targets.
-
-[TARGET_HAVE_SWITCHABLE_BSS_SECTIONS]
-
-[TARGET_HAVE_CTORS_DTORS]
-.. c:var:: bool TARGET_HAVE_CTORS_DTORS
-
- This value is true if the target supports some 'native' method of
- collecting constructors and destructors to be run at startup and exit.
- It is false if we must use :command:`collect2`.
-
-[TARGET_HAVE_CTORS_DTORS]
-
-[TARGET_DTORS_FROM_CXA_ATEXIT]
-.. c:var:: 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).
- It is false the method implied by ``have_ctors_dtors`` is used.
-
-[TARGET_DTORS_FROM_CXA_ATEXIT]
-
-[TARGET_HAVE_TLS]
-.. c:var:: bool TARGET_HAVE_TLS
-
- Contains the value true if the target supports thread-local storage.
- The default value is false.
-
-[TARGET_HAVE_TLS]
-
-[TARGET_HAVE_SRODATA_SECTION]
-.. c:var:: bool TARGET_HAVE_SRODATA_SECTION
-
- Contains the value true if the target places read-only
- 'small data' into a separate section. The default value is false.
-
-[TARGET_HAVE_SRODATA_SECTION]
-
-[TARGET_TERMINATE_DW2_EH_FRAME_INFO]
-.. c:var:: bool TARGET_TERMINATE_DW2_EH_FRAME_INFO
-
- Contains the value true if the target should add a zero word onto the
- end of a Dwarf-2 frame info section when used for exception handling.
- Default value is false if ``EH_FRAME_SECTION_NAME`` is defined, and
- true otherwise.
-
-[TARGET_TERMINATE_DW2_EH_FRAME_INFO]
-
-[TARGET_ASM_FILE_START_APP_OFF]
-.. c:var:: bool TARGET_ASM_FILE_START_APP_OFF
-
- If this flag is true, the text of the macro ``ASM_APP_OFF`` will be
- printed as the very first line in the assembly file, unless
- :option:`-fverbose-asm` is in effect. (If that macro has been defined
- to the empty string, this variable has no effect.) With the normal
- definition of ``ASM_APP_OFF``, the effect is to notify the GNU
- assembler that it need not bother stripping comments or extra
- whitespace from its input. This allows it to work a bit faster.
-
- The default is false. You should not set it to true unless you have
- verified that your port does not generate any extra whitespace or
- comments that will cause GAS to issue errors in NO_APP mode.
-
-[TARGET_ASM_FILE_START_APP_OFF]
-
-[TARGET_ASM_FILE_START_FILE_DIRECTIVE]
-.. c:var:: bool TARGET_ASM_FILE_START_FILE_DIRECTIVE
-
- If this flag is true, ``output_file_directive`` will be called
- for the primary source file, immediately after printing
- ``ASM_APP_OFF`` (if that is enabled). Most ELF assemblers expect
- this to be done. The default is false.
-
-[TARGET_ASM_FILE_START_FILE_DIRECTIVE]
-
-[TARGET_ARM_EABI_UNWINDER]
-.. c:var:: bool TARGET_ARM_EABI_UNWINDER
-
- This flag should be set to ``true`` on targets that use an ARM EABI
- based unwinding library, and ``false`` on other targets. This effects
- the format of unwinding tables, and how the unwinder in entered after
- running a cleanup. The default is ``false``.
-
-[TARGET_ARM_EABI_UNWINDER]
-
-[TARGET_WANT_DEBUG_PUB_SECTIONS]
-.. c:var:: bool TARGET_WANT_DEBUG_PUB_SECTIONS
-
- True if the ``.debug_pubtypes`` and ``.debug_pubnames`` sections
- should be emitted. These sections are not used on most platforms, and
- in particular GDB does not use them.
-
-[TARGET_WANT_DEBUG_PUB_SECTIONS]
-
-[TARGET_DELAY_SCHED2]
-.. c:var:: bool TARGET_DELAY_SCHED2
-
- True if sched2 is not to be run at its normal place.
- This usually means it will be run as part of machine-specific reorg.
-
-[TARGET_DELAY_SCHED2]
-
-[TARGET_DELAY_VARTRACK]
-.. c:var:: bool TARGET_DELAY_VARTRACK
-
- True if vartrack is not to be run at its normal place.
- This usually means it will be run as part of machine-specific reorg.
-
-[TARGET_DELAY_VARTRACK]
-
-[TARGET_NO_REGISTER_ALLOCATION]
-.. c:var:: bool TARGET_NO_REGISTER_ALLOCATION
-
- True if register allocation and the passes
- following it should not be run. Usually true only for virtual assembler
- targets.
-
-[TARGET_NO_REGISTER_ALLOCATION]
-
-[TARGET_MODE_EMIT]
-.. function:: void TARGET_MODE_EMIT (int entity, int mode, int prev_mode, HARD_REG_SET regs_live)
-
- Generate one or more insns to set :samp:`{entity}` to :samp:`{mode}`.
- :samp:`{hard_reg_live}` is the set of hard registers live at the point where
- the insn(s) are to be inserted. :samp:`{prev_moxde}` indicates the mode
- to switch from. Sets of a lower numbered entity will be emitted before
- sets of a higher numbered entity to a mode of the same or lower priority.
-
-[TARGET_MODE_EMIT]
-
-[TARGET_MODE_NEEDED]
-.. function:: int TARGET_MODE_NEEDED (int entity, rtx_insn *insn)
-
- :samp:`{entity}` is an integer specifying a mode-switched entity.
- If ``OPTIMIZE_MODE_SWITCHING`` is defined, you must define this macro
- to return an integer value not larger than the corresponding element
- in ``NUM_MODES_FOR_MODE_SWITCHING``, to denote the mode that :samp:`{entity}`
- must be switched into prior to the execution of :samp:`{insn}`.
-
-[TARGET_MODE_NEEDED]
-
-[TARGET_MODE_AFTER]
-.. function:: int TARGET_MODE_AFTER (int entity, int mode, rtx_insn *insn)
-
- :samp:`{entity}` is an integer specifying a mode-switched entity.
- If this macro is defined, it is evaluated for every :samp:`{insn}` during mode
- switching. It determines the mode that an insn results
- in (if different from the incoming mode).
-
-[TARGET_MODE_AFTER]
-
-[TARGET_MODE_ENTRY]
-.. function:: int TARGET_MODE_ENTRY (int entity)
-
- If this macro is defined, it is evaluated for every :samp:`{entity}` that
- needs mode switching. It should evaluate to an integer, which is a mode
- that :samp:`{entity}` is assumed to be switched to at function entry.
- If ``TARGET_MODE_ENTRY`` is defined then ``TARGET_MODE_EXIT``
- must be defined.
-
-[TARGET_MODE_ENTRY]
-
-[TARGET_MODE_EXIT]
-.. function:: int TARGET_MODE_EXIT (int entity)
-
- If this macro is defined, it is evaluated for every :samp:`{entity}` that
- needs mode switching. It should evaluate to an integer, which is a mode
- that :samp:`{entity}` is assumed to be switched to at function exit.
- If ``TARGET_MODE_EXIT`` is defined then ``TARGET_MODE_ENTRY``
- must be defined.
-
-[TARGET_MODE_EXIT]
-
-[TARGET_MODE_PRIORITY]
-.. function:: int TARGET_MODE_PRIORITY (int entity, int n)
-
- This macro specifies the order in which modes for :samp:`{entity}`
- are processed. 0 is the highest priority,
- ``NUM_MODES_FOR_MODE_SWITCHING[entity] - 1`` the lowest.
- The value of the macro should be an integer designating a mode
- for :samp:`{entity}`. For any fixed :samp:`{entity}`, ``mode_priority``
- (:samp:`{entity}`, :samp:`{n}`) shall be a bijection in 0 ...
- ``num_modes_for_mode_switching[entity] - 1``.
-
-[TARGET_MODE_PRIORITY]
-
-[TARGET_MEMTAG_CAN_TAG_ADDRESSES]
-.. function:: bool TARGET_MEMTAG_CAN_TAG_ADDRESSES ()
-
- True if the backend architecture naturally supports ignoring some region
- of pointers. This feature means that :option:`-fsanitize=hwaddress` can
- work.
-
- At preset, this feature does not support address spaces. It also requires
- ``Pmode`` to be the same as ``ptr_mode``.
-
-[TARGET_MEMTAG_CAN_TAG_ADDRESSES]
-
-[TARGET_MEMTAG_TAG_SIZE]
-.. function:: uint8_t TARGET_MEMTAG_TAG_SIZE ()
-
- Return the size of a tag (in bits) for this platform.
-
- The default returns 8.
-
-[TARGET_MEMTAG_TAG_SIZE]
-
-[TARGET_MEMTAG_GRANULE_SIZE]
-.. function:: uint8_t TARGET_MEMTAG_GRANULE_SIZE ()
-
- Return the size in real memory that each byte in shadow memory refers to.
- I.e. if a variable is :samp:`{X}` bytes long in memory, then this hook should
- return the value :samp:`{Y}` such that the tag in shadow memory spans
- :samp:`{X}` / :samp:`{Y}` bytes.
-
- Most variables will need to be aligned to this amount since two variables
- that are neighbors in memory and share a tag granule would need to share
- the same tag.
-
- The default returns 16.
-
-[TARGET_MEMTAG_GRANULE_SIZE]
-
-[TARGET_MEMTAG_INSERT_RANDOM_TAG]
-.. function:: rtx TARGET_MEMTAG_INSERT_RANDOM_TAG (rtx untagged, rtx target)
-
- Return an RTX representing the value of :samp:`{untagged}` but with a
- (possibly) random tag in it.
- Put that value into :samp:`{target}` if it is convenient to do so.
- This function is used to generate a tagged base for the current stack frame.
-
-[TARGET_MEMTAG_INSERT_RANDOM_TAG]
-
-[TARGET_MEMTAG_ADD_TAG]
-.. function:: rtx TARGET_MEMTAG_ADD_TAG (rtx base, poly_int64 addr_offset, uint8_t tag_offset)
-
- Return an RTX that represents the result of adding :samp:`{addr_offset}` to
- the address in pointer :samp:`{base}` and :samp:`{tag_offset}` to the tag in pointer
- :samp:`{base}`.
- The resulting RTX must either be a valid memory address or be able to get
- put into an operand with ``force_operand``.
-
- Unlike other memtag hooks, this must return an expression and not emit any
- RTL.
-
-[TARGET_MEMTAG_ADD_TAG]
-
-[TARGET_MEMTAG_SET_TAG]
-.. function:: rtx TARGET_MEMTAG_SET_TAG (rtx untagged_base, rtx tag, rtx target)
-
- Return an RTX representing :samp:`{untagged_base}` but with the tag :samp:`{tag}`.
- Try and store this in :samp:`{target}` if convenient.
- :samp:`{untagged_base}` is required to have a zero tag when this hook is called.
- The default of this hook is to set the top byte of :samp:`{untagged_base}` to
- :samp:`{tag}`.
-
-[TARGET_MEMTAG_SET_TAG]
-
-[TARGET_MEMTAG_EXTRACT_TAG]
-.. function:: rtx TARGET_MEMTAG_EXTRACT_TAG (rtx tagged_pointer, rtx target)
-
- Return an RTX representing the tag stored in :samp:`{tagged_pointer}`.
- Store the result in :samp:`{target}` if it is convenient.
- The default represents the top byte of the original pointer.
-
-[TARGET_MEMTAG_EXTRACT_TAG]
-
-[TARGET_MEMTAG_UNTAGGED_POINTER]
-.. function:: rtx TARGET_MEMTAG_UNTAGGED_POINTER (rtx tagged_pointer, rtx target)
-
- Return an RTX representing :samp:`{tagged_pointer}` with its tag set to zero.
- Store the result in :samp:`{target}` if convenient.
- The default clears the top byte of the original pointer.
-
-[TARGET_MEMTAG_UNTAGGED_POINTER]
-
-[TARGET_RUN_TARGET_SELFTESTS]
-.. function:: void TARGET_RUN_TARGET_SELFTESTS (void)
-
- If selftests are enabled, run any selftests for this target.
-
-[TARGET_RUN_TARGET_SELFTESTS]
-
-[TARGET_GCOV_TYPE_SIZE]
-.. function:: HOST_WIDE_INT TARGET_GCOV_TYPE_SIZE (void)
-
- Returns the gcov type size in bits. This type is used for example for
- counters incremented by profiling and code-coverage events. The default
- value is 64, if the type size of long long is greater than 32, otherwise the
- default value is 32. A 64-bit type is recommended to avoid overflows of the
- counters. If the :option:`-fprofile-update=atomic` is used, then the
- counters are incremented using atomic operations. Targets not supporting
- 64-bit atomic operations may override the default value and request a 32-bit
- type.
-
-[TARGET_GCOV_TYPE_SIZE]
-
-[TARGET_HAVE_SHADOW_CALL_STACK]
-.. c:var:: bool TARGET_HAVE_SHADOW_CALL_STACK
-
- This value is true if the target platform supports
- :option:`-fsanitize=shadow-call-stack`. The default value is false.
-
-[TARGET_HAVE_SHADOW_CALL_STACK]
-
-[TARGET_OBJC_CONSTRUCT_STRING_OBJECT]
-.. function:: tree TARGET_OBJC_CONSTRUCT_STRING_OBJECT (tree string)
-
- Targets may provide a string object type that can be used within
- and between C, C++ and their respective Objective-C dialects.
- A string object might, for example, embed encoding and length information.
- These objects are considered opaque to the compiler and handled as references.
- An ideal implementation makes the composition of the string object
- match that of the Objective-C ``NSString`` (``NXString`` for GNUStep),
- allowing efficient interworking between C-only and Objective-C code.
- If a target implements string objects then this hook should return a
- reference to such an object constructed from the normal 'C' string
- representation provided in :samp:`{string}`.
- At present, the hook is used by Objective-C only, to obtain a
- common-format string object when the target provides one.
-
-[TARGET_OBJC_CONSTRUCT_STRING_OBJECT]
-
-[TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE]
-.. function:: void TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE (const char *classname)
-
- Declare that Objective C class :samp:`{classname}` is referenced
- by the current TU.
-
-[TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE]
-
-[TARGET_OBJC_DECLARE_CLASS_DEFINITION]
-.. function:: void TARGET_OBJC_DECLARE_CLASS_DEFINITION (const char *classname)
-
- Declare that Objective C class :samp:`{classname}` is defined
- by the current TU.
-
-[TARGET_OBJC_DECLARE_CLASS_DEFINITION]
-
-[TARGET_STRING_OBJECT_REF_TYPE_P]
-.. function:: bool TARGET_STRING_OBJECT_REF_TYPE_P (const_tree stringref)
-
- If a target implements string objects then this hook should return
- ``true`` if :samp:`{stringref}` is a valid reference to such an object.
-
-[TARGET_STRING_OBJECT_REF_TYPE_P]
-
-[TARGET_CHECK_STRING_OBJECT_FORMAT_ARG]
-.. function:: void TARGET_CHECK_STRING_OBJECT_FORMAT_ARG (tree format_arg, tree args_list)
-
- If a target implements string objects then this hook should
- provide a facility to check the function arguments in :samp:`{args_list}`
- against the format specifiers in :samp:`{format_arg}` where the type of
- :samp:`{format_arg}` is one recognized as a valid string reference type.
-
-[TARGET_CHECK_STRING_OBJECT_FORMAT_ARG]
-
-[TARGET_C_PREINCLUDE]
-.. function:: const char * TARGET_C_PREINCLUDE (void)
-
- Define this hook to return the name of a header file to be included at
- the start of all compilations, as if it had been included with
- ``#include <file>``. If this hook returns ``NULL``, or is
- not defined, or the header is not found, or if the user specifies
- :option:`-ffreestanding` or :option:`-nostdinc`, no header is included.
-
- This hook can be used together with a header provided by the system C
- library to implement ISO C requirements for certain macros to be
- predefined that describe properties of the whole implementation rather
- than just the compiler.
-
-[TARGET_C_PREINCLUDE]
-
-[TARGET_CXX_IMPLICIT_EXTERN_C]
-.. function:: bool TARGET_CXX_IMPLICIT_EXTERN_C (const char*)
-
- Define this hook to add target-specific C++ implicit extern C functions.
- If this function returns true for the name of a file-scope function, that
- function implicitly gets extern "C" linkage rather than whatever language
- linkage the declaration would normally have. An example of such function
- is WinMain on Win32 targets.
-
-[TARGET_CXX_IMPLICIT_EXTERN_C]
-
-[TARGET_OPTION_INIT_STRUCT]
-.. function:: void TARGET_OPTION_INIT_STRUCT (struct gcc_options *opts)
-
- Set target-dependent initial values of fields in :samp:`{opts}`.
-
-[TARGET_OPTION_INIT_STRUCT]
-
-[TARGET_SUPPORTS_SPLIT_STACK]
-.. function:: bool TARGET_SUPPORTS_SPLIT_STACK (bool report, struct gcc_options *opts)
-
- Whether this target supports splitting the stack when the options
- described in :samp:`{opts}` have been passed. This is called
- after options have been parsed, so the target may reject splitting
- the stack in some configurations. The default version of this hook
- returns false. If :samp:`{report}` is true, this function may issue a warning
- or error; if :samp:`{report}` is false, it must simply return a value
-
-[TARGET_SUPPORTS_SPLIT_STACK]
-
-[TARGET_GET_VALID_OPTION_VALUES]
-.. function:: vec<const char *> TARGET_GET_VALID_OPTION_VALUES (int option_code, const char *prefix)
-
- The hook is used for options that have a non-trivial list of
- possible option values. OPTION_CODE is option code of opt_code
- enum type. PREFIX is used for bash completion and allows an implementation
- to return more specific completion based on the prefix. All string values
- should be allocated from heap memory and consumers should release them.
- The result will be pruned to cases with PREFIX if not NULL.
-
-[TARGET_GET_VALID_OPTION_VALUES]
-
-[TARGET_COMPUTE_MULTILIB]
-.. function:: const char * TARGET_COMPUTE_MULTILIB (const struct switchstr *switches, int n_switches, const char *multilib_dir, const char *multilib_defaults, const char *multilib_select, const char *multilib_matches, const char *multilib_exclusions, const char *multilib_reuse)
-
- Some targets like RISC-V might have complicated multilib reuse rules which
- are hard to implement with the current multilib scheme. This hook allows
- targets to override the result from the built-in multilib mechanism.
- :samp:`{switches}` is the raw option list with :samp:`{n_switches}` items;
- :samp:`{multilib_dir}` is the multi-lib result which is computed by the built-in
- multi-lib mechanism;
- :samp:`{multilib_defaults}` is the default options list for multi-lib;
- :samp:`{multilib_select}` is the string containing the list of supported
- multi-libs, and the option checking list.
- :samp:`{multilib_matches}`, :samp:`{multilib_exclusions}`, and :samp:`{multilib_reuse}`
- are corresponding to :samp:`{MULTILIB_MATCHES}`, :samp:`{MULTILIB_EXCLUSIONS}`,
- and :samp:`{MULTILIB_REUSE}`.
- The default definition does nothing but return :samp:`{multilib_dir}` directly.
-
-[TARGET_COMPUTE_MULTILIB]
-
-[TARGET_ALWAYS_STRIP_DOTDOT]
-.. c:var:: bool TARGET_ALWAYS_STRIP_DOTDOT
-
- True if :samp:`..` components should always be removed from directory names
- computed relative to GCC's internal directories, false (default) if such
- components should be preserved and directory names containing them passed
- to other tools such as the linker.
-
-[TARGET_ALWAYS_STRIP_DOTDOT]
-
-[TARGET_D_CPU_VERSIONS]
-.. function:: void TARGET_D_CPU_VERSIONS (void)
-
- Declare all environmental version identifiers relating to the target CPU
- using the function ``builtin_version``, which takes a string representing
- the name of the version. Version identifiers predefined by this hook apply
- to all modules that are being compiled and imported.
-
-[TARGET_D_CPU_VERSIONS]
-
-[TARGET_D_OS_VERSIONS]
-.. function:: void TARGET_D_OS_VERSIONS (void)
-
- Similarly to ``TARGET_D_CPU_VERSIONS``, but is used for versions
- relating to the target operating system.
-
-[TARGET_D_OS_VERSIONS]
-
-[TARGET_D_REGISTER_CPU_TARGET_INFO]
-.. function:: void TARGET_D_REGISTER_CPU_TARGET_INFO (void)
-
- Register all target information keys relating to the target CPU using the
- function ``d_add_target_info_handlers``, which takes a
- :samp:`struct d_target_info_spec` (defined in :samp:`d/d-target.h`). The keys
- added by this hook are made available at compile time by the
- ``__traits(getTargetInfo)`` extension, the result is an expression
- describing the requested target information.
-
-[TARGET_D_REGISTER_CPU_TARGET_INFO]
-
-[TARGET_D_REGISTER_OS_TARGET_INFO]
-.. function:: void TARGET_D_REGISTER_OS_TARGET_INFO (void)
-
- Same as ``TARGET_D_CPU_TARGET_INFO``, but is used for keys relating to
- the target operating system.
-
-[TARGET_D_REGISTER_OS_TARGET_INFO]
-
-[TARGET_D_MINFO_SECTION]
-.. c:var:: const char * TARGET_D_MINFO_SECTION
-
- Contains the name of the section in which module info references should be
- placed. By default, the compiler puts all module info symbols in the
- ``"minfo"`` section. Define this macro to override the string if a
- different section name should be used. This section is expected to be
- bracketed by two symbols ``TARGET_D_MINFO_SECTION_START`` and
- ``TARGET_D_MINFO_SECTION_END`` to indicate the start and end address of
- the section, so that the runtime library can collect all modules for each
- loaded shared library and executable. Setting the value to ``NULL``
- disables the use of sections for storing module info altogether.
-
-[TARGET_D_MINFO_SECTION]
-
-[TARGET_D_MINFO_SECTION_START]
-.. c:var:: const char * TARGET_D_MINFO_SECTION_START
-
- If ``TARGET_D_MINFO_SECTION`` is defined, then this must also be defined
- as the name of the symbol indicating the start address of the module info
- section
-
-[TARGET_D_MINFO_SECTION_START]
-
-[TARGET_D_MINFO_SECTION_END]
-.. c:var:: const char * TARGET_D_MINFO_SECTION_END
-
- If ``TARGET_D_MINFO_SECTION`` is defined, then this must also be defined
- as the name of the symbol indicating the end address of the module info
- section
-
-[TARGET_D_MINFO_SECTION_END]
-
-[TARGET_D_HAS_STDCALL_CONVENTION]
-.. function:: bool TARGET_D_HAS_STDCALL_CONVENTION (unsigned int *link_system, unsigned int *link_windows)
-
- Returns ``true`` if the target supports the stdcall calling convention.
- The hook should also set :samp:`{link_system}` to ``1`` if the ``stdcall``
- attribute should be applied to functions with ``extern(System)`` linkage,
- and :samp:`{link_windows}` to ``1`` to apply ``stdcall`` to functions with
- ``extern(Windows)`` linkage.
-
-[TARGET_D_HAS_STDCALL_CONVENTION]
-
-[TARGET_D_TEMPLATES_ALWAYS_COMDAT]
-.. c:var:: bool TARGET_D_TEMPLATES_ALWAYS_COMDAT
-
- This flag is true if instantiated functions and variables are always COMDAT
- if they have external linkage. If this flag is false, then instantiated
- decls will be emitted as weak symbols. The default is ``false``.
-
-[TARGET_D_TEMPLATES_ALWAYS_COMDAT]
-
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2022-11-14 8:39 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-11-14 8:39 [gcc r13-3994] Revert "sphinx: add tm.rst.in" Martin Liska
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).