Lines Matching +refs:dwarf +refs:mode
530 /* Return a section for X. MODE is X's mode and ALIGN is its
534 "Return the section into which a constant @var{x}, of mode @var{mode},\n\
536 constant in RTL@. The argument @var{mode} is redundant except in the\n\
541 constants in @code{flag_pic} mode in @code{data_section} and everything\n\
543 section *, (machine_mode mode, rtx x, unsigned HOST_WIDE_INT align),
850 output of assembler code for @var{insn}, to change the mode of the assembler\n\
857 template into assembler code, so you can change the assembler mode\n\
922 void, (FILE *file, machine_mode mode, rtx addr),
1556 int, (unsigned int opc, machine_mode mode),
1847 vectors of mode @var{mode} using the permutation vector @code{sel}, and\n\
1851 registers of mode @var{mode}. @var{in1} is the same as @var{in0} if\n\
1858 If the hook returns false for a mode with multibyte elements, GCC will\n\
1860 the selector into a register and using the @var{vec_perm@var{mode}}\n\
1863 bool, (machine_mode mode, rtx output, rtx in0, rtx in1,
1874 parameter. The vector store/load should be of machine mode @var{mode} and\n\
1878 (machine_mode mode, const_tree type, int misalignment, bool is_packed),
1881 /* Returns the preferred mode for SIMD operations for the specified
1882 scalar mode. */
1885 "This hook should return the preferred mode for vectorizing scalar\n\
1886 mode @var{mode}. The default is\n\
1890 (scalar_mode mode),
1893 /* Returns the preferred mode for splitting SIMD reductions to. */
1896 "This hook should return the preferred mode to split the final reduction\n\
1897 step on @var{mode} to. The reduction is then carried out reducing upper\n\
1898 against lower halves of vectors recursively until the specified mode is\n\
1899 reached. The default is @var{mode} which means no splitting.",
1908 "If the mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE} is not\n\
1920 /* Function to get a target mode for a vector mask. */
1924 in a vector. This hook returns the machine mode that should be used to\n\
1927 @code{opt_machine_mode} if no such mode exists.\n\
1929 The default implementation returns the mode of an integer vector that\n\
1931 if such a mode exists.",
2071 "Return machine mode for filter value.",
2075 /* Return machine mode for libgcc expanded cmp instructions. */
2078 "This target hook should return the mode to be used for the return value\n\
2085 /* Return machine mode for libgcc expanded shift instructions. */
2088 "This target hook should return the mode to be used for the shift count operand\n\
2095 /* Return machine mode to be used for _Unwind_Word type. */
2098 "Return machine mode to be used for @code{_Unwind_Word} type.\n\
2301 should use the narrowest mode possible. It should return @code{false} if\n\
2351 convenient, and have mode @var{mode} if that is convenient.\n\
2357 (tree exp, rtx target, rtx subtarget, machine_mode mode, int ignore),
2442 "Return mode to be used for bounds.",
2754 /* True if X is a legitimate MODE-mode immediate operand. */
2758 @var{mode}-mode immediate operand on the target machine. You can assume that\n\
2762 bool, (machine_mode mode, rtx x),
2769 should not) be spilled to the constant pool. @var{mode} is the mode\n\
2779 bool, (machine_mode mode, rtx x),
2798 on the mode of the memory reference it is used in. */
2803 different meanings depending on the machine mode of the memory\n\
2807 Autoincrement and autodecrement addresses typically have mode-dependent\n\
2809 of the operand being addressed. Some machines have other mode-dependent\n\
2810 addresses. Many RISC machines have no mode-dependent addresses.\n\
2818 /* Given an invalid address X for a given machine mode, try machine-specific
2823 operand of mode @var{mode} and should try to return a valid memory\n\
2842 rtx, (rtx x, rtx oldx, machine_mode mode),
2871 address on the target machine for a memory operand of mode @var{mode}.\n\
2917 #define GO_IF_LEGITIMATE_ADDRESS (@var{mode}, @var{x}, @var{label})\n\
2922 address on the target machine for a memory operand of mode @var{mode}.\n\
2932 bool, (machine_mode mode, rtx x, bool strict),
2939 be placed in an @code{object_block} structure. @var{mode} is the mode\n\
2943 bool, (machine_mode mode, const_rtx x),
2962 for every mode. The default value is 0.",
3149 "This function describes how the standard shift patterns for @var{mode}\n\
3150 deal with shifts by negative amounts or by more than the width of the mode.\n\
3156 this is true for mode @var{mode}, the function should return @var{m},\n\
3165 @code{GET_MODE_BITSIZE (@var{mode}) - 1} if @code{SHIFT_COUNT_TRUNCATED}\n\
3170 unsigned HOST_WIDE_INT, (machine_mode mode),
3182 of mode @var{mode}. The default implementation returns 3 if the machine\n\
3184 unsigned int, (machine_mode mode),
3197 mode sizes. Making this hook return false in such cases may improve things.",
3202 always sign-extended to a wider mode MODE_REP then return
3208 "The representation of an integral mode can be such that the values\n\
3209 are always extended to a wider integral mode. Return\n\
3210 @code{SIGN_EXTEND} if values of @var{mode} are represented in\n\
3216 @var{mode} to @var{rep_mode} so that @var{rep_mode} is not the next\n\
3217 widest integral mode and currently we take advantage of this fact.)\n\
3226 @code{TARGET_MODE_REP_EXTENDED (mode, word_mode)} you probably also want\n\
3227 to define @code{LOAD_EXTEND_OP (mode)} to return the same type of\n\
3230 In order to enforce the representation of @code{mode},\n\
3232 @code{mode}.",
3233 int, (scalar_int_mode mode, scalar_int_mode rep_mode),
3236 /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */
3240 with machine mode @var{mode}. The default version of this\n\
3242 bool, (scalar_int_mode mode),
3264 "Define this to return the machine mode to use for pointers to\n\
3273 "Define this to return the machine mode to use for addresses in\n\
3279 /* True if MODE is valid for a pointer in __attribute__((mode("MODE")))
3284 with machine mode @var{mode} to address space @var{as}. This target\n\
3290 bool, (scalar_int_mode mode, addr_space_t as),
3294 space for a given mode. */
3297 "Define this to return true if @var{exp} is a valid address for mode\n\
3298 @var{mode} in the named address space @var{as}. The @var{strict}\n\
3303 bool, (machine_mode mode, rtx exp, bool strict, addr_space_t as),
3312 with mode @var{mode} in the named address space @var{as}. This target\n\
3315 rtx, (rtx x, rtx oldx, machine_mode mode, addr_space_t as),
3351 /* Function to encode an address space into dwarf. */
3354 "Define this to define how the address space is encoded in dwarf.\n\
3381 statically-allocated rtx, such as a constant pool entry. @var{mode}\n\
3382 is the mode of the rtx. The default implementation returns\n\
3383 @samp{GET_MODE_ALIGNMENT (@var{mode})}.",
3384 HOST_WIDE_INT, (machine_mode mode),
3408 insns involving scalar mode @var{mode}. For a scalar mode to be\n\
3412 The default version of this hook returns true for any mode\n\
3416 bool, (scalar_mode mode),
3425 insns involving vector mode @var{mode}. At the very least, it\n\
3426 must have move patterns for this mode.",
3427 bool, (machine_mode mode),
3442 "Return the mode that GCC should use for an array that has\n\
3443 @var{nelems} elements, with each element having mode @var{mode}.\n\
3444 Return no mode if the target has no special requirements. In the\n\
3445 latter case, GCC looks for an integer mode of the appropriate size\n\
3447 integer mode is limited to @code{MAX_FIXED_MODE_SIZE}, but the\n\
3448 @code{TARGET_ARRAY_MODE_SUPPORTED_P} hook allows a larger mode to be\n\
3452 also have a vector mode. The default implementation returns no mode.",
3453 opt_machine_mode, (machine_mode mode, unsigned HOST_WIDE_INT nelems),
3456 /* True if we should try to use a scalar mode to represent an array,
3460 "Return true if GCC should try to use a scalar mode to store an array\n\
3461 of @var{nelems} elements, given that each element has mode @var{mode}.\n\
3463 and allows GCC to use any defined integer mode.\n\
3482 If this hook allows @code{val} to have a scalar mode, then\n\
3483 @code{int8x8x3_t} can have the same mode. GCC can then store\n\
3485 bool, (machine_mode mode, unsigned HOST_WIDE_INT nelems),
3491 floating-point mode @var{mode}, which is known to pass \n\
3495 bool, (scalar_float_mode mode),
3500 "Define this to return the machine mode to use for the type \n\
3525 the GNU C langauge. In strict ANSI/ISO mode, the built-in function without\n\
3535 "This target hook should return the cost of moving data of mode @var{mode}\n\
3553 int, (machine_mode mode, reg_class_t from, reg_class_t to),
3561 "This target hook should return the cost of moving data of mode @var{mode}\n\
3582 int, (machine_mode mode, reg_class_t rclass, bool in),
3629 one comparison per @var{mode}-sized piece. A port can also prevent a\n\
3630 particular mode from being used for block comparisons by returning a\n\
3632 int, (machine_mode mode),
3638 @var{mode} and @var{alignment} parameters have a cost many times greater\n\
3641 @code{@var{alignment} < GET_MODE_ALIGNMENT (@var{mode})}.\n\
3651 bool, (machine_mode mode, unsigned int align),
3671 /* True for MODE if the target expects that registers in this mode will
3679 @var{mode}, the compiler will try to minimize the lifetime of registers\n\
3680 in @var{mode}. The hook may be called with @code{VOIDmode} as argument.\n\
3682 for any mode.\n\
3700 The default version of this hook returns false for any mode. It is always\n\
3706 bool, (machine_mode mode),
3735 @var{mode} is @var{x}'s machine mode, or for cases like @code{const_int} that\n\
3736 do not have a mode, the mode in which @var{x} is used.\n\
3754 bool, (rtx x, machine_mode mode, int outer_code, int opno, int *total, bool speed),
3761 "This hook computes the cost of an addressing mode that contains\n\
3766 true cost of the addressing mode. However, on RISC machines, all\n\
3778 the cost of the addressing mode containing the sum is no higher than\n\
3793 int, (rtx address, machine_mode mode, addr_space_t as, bool speed),
3819 @code{mov@var{mode}cc} insns. This hook returns the maximum cost of the\n\
3820 unconditional instructions and the @code{mov@var{mode}cc} insns.\n\
3904 if the register and its mode are represented in Dwarf in
3912 register and its mode are represented in Dwarf in non-contiguous\n\
3919 /* Given a register return the mode of the corresponding DWARF frame
3923 "Given a register, this hook should return the mode which the\n\
3925 used to return a smaller mode than the raw mode to prevent call\n\
3970 code mode which is compatible with both, such that a comparison
3971 done in the returned mode will work for both of the original
3978 validly done in more than one mode. On such a system, define this\n\
3979 target hook to take two mode arguments and to return a mode in which\n\
3980 both comparisons may be validly done. If there is no such mode,\n\
3984 same. If they are, it returns that mode. If they are different, it\n\
4166 "Define this to enable the dwarf attribute @code{DW_AT_calling_convention} to\n\
4355 function return values. The target hook should return the new mode\n\
4363 If it is @code{2}, the returned mode should be that of the register in\n\
4365 then the hook should return the same mode as @code{promote_mode}, though\n\
4373 machine_mode, (const_tree type, machine_mode mode, int *punsignedp,
4429 Note that values of mode @code{BLKmode} must be explicitly handled\n\
4472 (cumulative_args_t cum, machine_mode mode, const_tree type, bool named),
4498 named arguments. The arguments @var{mode} and @var{type} describe the\n\
4499 last named argument---its machine mode and its data type as a tree node.\n\
4519 void, (cumulative_args_t args_so_far, machine_mode mode, tree type,
4567 void, (cumulative_args_t args_so_far, machine_mode mode, tree type,
4645 /* Return true if type T, mode MODE, may not be passed in registers,
4655 bool, (machine_mode mode, const_tree type),
4658 /* Return true if type TYPE, mode MODE, which is passed by reference,
4674 (cumulative_args_t cum, machine_mode mode, const_tree type, bool named),
4698 int, (cumulative_args_t cum, machine_mode mode, tree type, bool named),
4707 advance past an argument in the argument list. The values @var{mode},\n\
4716 (cumulative_args_t ca, machine_mode mode, const_tree type, bool named),
4722 argument of type @var{type} and mode @var{mode} when passed in memory.\n\
4726 HOST_WIDE_INT, (machine_mode mode, const_tree type),
4732 an argument of mode @var{mode} and type @var{type}. It returns\n\
4744 pad_direction, (machine_mode mode, const_tree type),
4757 arguments; @var{mode}, the machine mode of the argument; @var{type},\n\
4776 used when an argument is passed in multiple locations. The mode of the\n\
4777 @code{parallel} should be the mode of the entire argument. The\n\
4781 register in which to pass this part of the argument, and the mode of the\n\
4809 rtx, (cumulative_args_t ca, machine_mode mode, const_tree type,
4832 rtx, (cumulative_args_t ca, machine_mode mode, const_tree type,
4839 with the specified mode and type. The default hook returns\n\
4841 unsigned int, (machine_mode mode, const_tree type),
4850 unsigned int, (machine_mode mode, const_tree type),
4879 place regardless of mode.) The value of the expression is usually a\n\
4920 /* Return the rtx for the result of a libcall of mode MODE,
4927 The mode of the result is given by @var{mode} and the name of the called\n\
4932 rtx, (machine_mode mode, const_rtx fun),
5118 /* Return a mode wide enough to copy any function value that might be
5122 "This target hook returns the mode to be used when accessing raw return\
5128 /* Return a mode wide enough to copy any argument value that might be
5132 "This target hook returns the mode to be used when accessing raw argument\
5233 registers of class @var{rclass} from mode @var{from} to mode @var{to}\n\
5250 Even if storing from a register in mode @var{to} would be valid,\n\
5253 mode. This happens when the middle-end assumes that it can load\n\
5256 Failure to prevent this kind of mode change will result in the\n\
5318 displacement can depend on memory mode or on operand combinations in\
5325 /* Determine class for spilling pseudos of given mode into registers
5330 pseudos of the given mode and class, or @code{NO_REGS} if only memory\
5350 "This hook defines the machine mode to use for the boolean result of\
5353 as accepting the mode encoded into operand 0 of the cstore expander\
5375 If @var{field} is the only field in the structure, @var{mode} is its\n\
5376 mode, otherwise @var{mode} is VOIDmode. @var{mode} is provided in the\n\
5377 case where structures of one field would require the structure's mode to\n\
5378 retain the field's mode.\n\
5381 bool, (const_tree field, machine_mode mode),
5390 void, (rtx libfunc, machine_mode mode, rtx op0, rtx op1, rtx *quot, rtx *rem),
5403 destination. An intermediate register always has the same mode as\n\
5413 when compiling PIC)@. Scratch registers need not have the same mode\n\
5417 these patterns also describe the number, register class(es) and mode(s)\n\
5444 for scratch operands. These scratch operands must have a mode, and a\n\
5455 @c the port maintainer could name a mov<mode> pattern that has clobbers -\n\
5488 those machines to return true if objects of mode @var{m} in registers\n\
5493 bool, (machine_mode mode, reg_class_t class1, reg_class_t class2),
5499 when moving between two particular registers of mode @var{mode},\n\
5500 this hook specifies the mode that the memory should have.\n\
5503 is to use a word-sized mode for integral modes that are smaller than a\n\
5506 registers in a narrower mode, which some machines prohibit for\n\
5516 With LRA, the default is to use @var{mode} unmodified.",
5517 machine_mode, (machine_mode mode),
5607 needed to represent mode MODE in a register of class RCLASS. */
5611 of class @var{rclass} needed to hold a value of mode @var{mode}.\n\
5615 @var{mode})} target hook should be the maximum value of\n\
5616 @code{TARGET_HARD_REGNO_NREGS (@var{regno}, @var{mode})} for all @var{regno}\n\
5622 The default version of this target hook returns the size of @var{mode}\n\
5624 unsigned char, (reg_class_t rclass, machine_mode mode),
5663 to the anchor to address a value of mode @var{mode}. The idea is that\n\
5669 bool, (rtx *offset1, rtx *offset2, poly_int64 orig_offset, machine_mode mode),
5698 at register number @var{regno}, required to hold a value of mode\n\
5699 @var{mode}. This hook must never return zero, even if a register\n\
5700 cannot hold the requested mode - indicate that with\n\
5704 The default definition returns the number of words in @var{mode}.",
5705 unsigned int, (unsigned int regno, machine_mode mode),
5711 of mode @var{mode} in hard register number @var{regno} (or in several\n\
5723 The minimum requirement for a mode to be OK in a register is that the\n\
5724 @samp{mov@var{mode}} instruction pattern support moves between the\n\
5740 mode, whether or not floating arithmetic can be done on it in those\n\
5750 unchanged without a trap, then any machine mode may go in a floating\n\
5764 bool, (unsigned int regno, machine_mode mode),
5769 "This hook returns true if a value of mode @var{mode1} is accessible\n\
5770 in mode @var{mode2} without copying.\n\
5778 accessibility of the value in a narrower mode.\n\
5803 partly call-clobbered, and if a value of mode @var{mode} would be partly\n\
5806 return true for a 64-bit mode but false for a 32-bit mode.\n\
5810 bool, (unsigned int regno, machine_mode mode),
5939 "Return machine mode for non-standard constant literal suffix @var{c},\
6524 atomic object of machine_mode @var{mode}. If 0 is returned then the\
6525 default alignment for the specified mode is used. ",
6526 unsigned int, (machine_mode mode),
6605 comments that will cause GAS to issue errors in NO_APP mode.",
6653 /* Functions related to mode switching. */
6660 …mode}. @var{hard_reg_live} is the set of hard registers live at the point where the insn(s) are to…
6661 void, (int entity, int mode, int prev_mode, HARD_REG_SET regs_live), NULL)
6665 …mode-switched entity. If @code{OPTIMIZE_MODE_SWITCHING} is defined, you must define this macro to…
6670 …mode-switched entity. If this macro is defined, it is evaluated for every @var{insn} during mode …
6671 int, (int entity, int mode, rtx_insn *insn), NULL)
6675 …valuated for every @var{entity} that needs mode switching. It should evaluate to an integer, whic…
6680 …valuated for every @var{entity} that needs mode switching. It should evaluate to an integer, whic…
6685 …1} the lowest. The value of the macro should be an integer designating a mode for @var{entity}. …