Lines Matching +refs:dwarf +refs:mode
52 * Mode Switching:: Insertion of mode-switching instructions.
933 is @var{type} and which has the specified mode and signedness is to be
939 @var{m} is an integer mode narrower than @code{BITS_PER_WORD}. In most
954 …RGET_PROMOTE_FUNCTION_MODE (const_tree @var{type}, enum machine_mode @var{mode}, int *@var{punsign…
956 function return values. The target hook should return the new mode
964 If it is @code{2}, the returned mode should be that of the register in
966 then the hook should return the same mode as @code{promote_mode}, though
1124 @defmac STACK_SLOT_ALIGNMENT (@var{type}, @var{mode}, @var{basic-align})
1126 @var{type} is the data type, @var{mode} is the widest mode available,
1155 @defmac MINIMUM_ALIGNMENT (@var{exp}, @var{mode}, @var{align})
1158 @var{mode}, assuming normal alignment @var{align}.
1265 should use the narrowest mode possible. It should return @code{false} if
1271 @defmac MEMBER_TYPE_FORCES_BLK (@var{field}, @var{mode})
1275 If @var{field} is the only field in the structure, @var{mode} is its
1276 mode, otherwise @var{mode} is VOIDmode. @var{mode} is provided in the
1277 case where structures of one field would require the structure's mode to
1278 retain the field's mode.
1295 machine mode that should actually be used. All integer machine modes of
1303 specifies the mode of the save area operand of a
1307 having its mode specified.
1312 64-bit mode.
1317 specifies the mode of the size increment operand of an
1322 pattern needs to support both a 32- and a 64-bit mode.
1326 This target hook should return the mode to be used for the return value
1333 This target hook should return the mode to be used for the shift count operand
1340 Return machine mode to be used for @code{_Unwind_Word} type.
1346 mode is towards zero.
1798 address is in ARM or Thumb mode. If this is the case of your
1915 @defmac HARD_REGNO_CALL_PART_CLOBBERED (@var{regno}, @var{mode})
1920 value of mode @var{mode} in hard register number @var{regno} across a
2055 consecutive registers are needed for a given mode.
2057 @defmac HARD_REGNO_NREGS (@var{regno}, @var{mode})
2059 at register number @var{regno}, required to hold a value of mode
2060 @var{mode}. This macro must never return zero, even if a register
2061 cannot hold the requested mode - indicate that with HARD_REGNO_MODE_OK
2074 @defmac HARD_REGNO_NREGS_HAS_PADDING (@var{regno}, @var{mode})
2075 A C expression that is nonzero if a value of mode @var{mode}, stored
2079 this mode by the number of registers returned by
2094 @defmac HARD_REGNO_NREGS_WITH_PADDING (@var{regno}, @var{mode})
2095 For values of @var{regno} and @var{mode} for which
2101 @defmac REGMODE_NATURAL_SIZE (@var{mode})
2103 of mode @var{mode} is not the word size. It is a C expression that
2104 should give the natural size in bytes for the specified mode. It is
2110 @defmac HARD_REGNO_MODE_OK (@var{regno}, @var{mode})
2112 of mode @var{mode} in hard register number @var{regno} (or in several
2128 The minimum requirement for a mode to be OK in a register is that the
2129 @samp{mov@var{mode}} instruction pattern support moves between the
2145 mode, whether or not floating arithmetic can be done on it in those
2155 unchanged without a trap, then any machine mode may go in a floating
2183 A C expression that is nonzero if a value of mode
2184 @var{mode1} is accessible in mode @var{mode2} without copying.
2191 accessibility of the value in a narrower mode.
2354 some mode, the move cost between registers within the class is
2379 each fixed-point machine mode, a subclass whose registers can transfer that
2380 mode to or from memory. For example, on some machines, the operations for
2440 @defmac MODE_BASE_REG_CLASS (@var{mode})
2442 the selection of a base register in a mode dependent manner. If
2443 @var{mode} is VOIDmode then it should return the same value as
2447 @defmac MODE_BASE_REG_REG_CLASS (@var{mode})
2454 @defmac MODE_CODE_BASE_REG_CLASS (@var{mode}, @var{address_space}, @var{outer_code}, @var{index_cod…
2456 base register for a memory reference in mode @var{mode} to address
2477 @defmac REGNO_MODE_OK_FOR_BASE_P (@var{num}, @var{mode})
2479 that expression may examine the mode of the memory reference in
2480 @var{mode}. You should define this macro if the mode of the memory
2483 @code{REGNO_OK_FOR_BASE_P}. The mode may be @code{VOIDmode} for
2488 @defmac REGNO_MODE_OK_FOR_REG_BASE_P (@var{num}, @var{mode})
2491 memory in mode @var{mode}. It may be either a suitable hard register or a
2500 @defmac REGNO_MODE_CODE_OK_FOR_BASE_P (@var{num}, @var{mode}, @var{address_space}, @var{outer_code}…
2503 memory in mode @var{mode} in address space @var{address_space}.
2511 @code{SCRATCH} otherwise. The mode may be @code{VOIDmode} for addresses
2617 @defmac LIMIT_RELOAD_CLASS (@var{mode}, @var{class})
2619 to use when it is necessary to be able to hold a value of mode
2620 @var{mode} in a reload register for which class @var{class} would
2641 destination. An intermediate register always has the same mode as
2651 when compiling PIC)@. Scratch registers need not have the same mode
2655 these patterns also describe the number, register class(es) and mode(s)
2682 for scratch operands. These scratch operands must have a mode, and a
2693 @c the port maintainer could name a mov<mode> pattern that has clobbers -
2719 @defmac SECONDARY_RELOAD_CLASS (@var{class}, @var{mode}, @var{x})
2720 @defmacx SECONDARY_INPUT_RELOAD_CLASS (@var{class}, @var{mode}, @var{x})
2721 @defmacx SECONDARY_OUTPUT_RELOAD_CLASS (@var{class}, @var{mode}, @var{x})
2730 register @var{class} in @var{mode} requires an intermediate register,
2735 If copying a register @var{class} in @var{mode} to @var{x} requires an
2746 @var{mode} without requiring a scratch register. Do not define this
2782 those machines to be a C expression that is nonzero if objects of mode
2790 @defmac SECONDARY_MEMORY_NEEDED_RTX (@var{mode})
2800 @defmac SECONDARY_MEMORY_NEEDED_MODE (@var{mode})
2802 registers of mode @var{mode}, it normally allocates sufficient memory to
2804 load operations in a mode that many bits wide and whose class is the
2805 same as that of @var{mode}.
2809 in a narrower mode, which some machines prohibit for floating-point
2820 @code{SECONDARY_MEMORY_NEEDED} or if widening @var{mode} to a mode that
2842 …ok} {unsigned char} TARGET_CLASS_MAX_NREGS (reg_class_t @var{rclass}, enum machine_mode @var{mode})
2844 of class @var{rclass} needed to hold a value of mode @var{mode}.
2848 @var{mode})} target hook should be the maximum value of
2849 @code{HARD_REGNO_NREGS (@var{regno}, @var{mode})} for all @var{regno}
2855 The default version of this target hook returns the size of @var{mode}
2859 @defmac CLASS_MAX_NREGS (@var{class}, @var{mode})
2861 of class @var{class} needed to hold a value of mode @var{mode}.
2864 the value of the macro @code{CLASS_MAX_NREGS (@var{class}, @var{mode})}
2866 @var{mode})} for all @var{regno} values in the class @var{class}.
2874 a change from mode @var{from} to mode @var{to} is invalid.
3693 Define this macro if the target's representation for dwarf registers
3695 Given a dwarf register, this macro should return the internal unwind
3703 Define this macro if the target's representation for dwarf registers
3999 …x TARGET_FUNCTION_ARG (cumulative_args_t @var{ca}, enum machine_mode @var{mode}, const_tree @var{t…
4004 arguments; @var{mode}, the machine mode of the argument; @var{type},
4017 used when an argument is passed in multiple locations. The mode of the
4018 @code{parallel} should be the mode of the entire argument. The
4022 register in which to pass this part of the argument, and the mode of the
4052 @deftypefn {Target Hook} bool TARGET_MUST_PASS_IN_STACK (enum machine_mode @var{mode}, const_tree @…
4059 …FUNCTION_INCOMING_ARG (cumulative_args_t @var{ca}, enum machine_mode @var{mode}, const_tree @var{t…
4075 …ET_ARG_PARTIAL_BYTES (cumulative_args_t @var{cum}, enum machine_mode @var{mode}, tree @var{type}, …
4094 …ET_PASS_BY_REFERENCE (cumulative_args_t @var{cum}, enum machine_mode @var{mode}, const_tree @var{t…
4106 …TARGET_CALLEE_COPIES (cumulative_args_t @var{cum}, enum machine_mode @var{mode}, const_tree @var{t…
4164 @defmac INIT_CUMULATIVE_LIBCALL_ARGS (@var{cum}, @var{mode}, @var{libname})
4185 …_FUNCTION_ARG_ADVANCE (cumulative_args_t @var{ca}, enum machine_mode @var{mode}, const_tree @var{t…
4187 advance past an argument in the argument list. The values @var{mode},
4197 @defmac FUNCTION_ARG_OFFSET (@var{mode}, @var{type})
4205 @defmac FUNCTION_ARG_PADDING (@var{mode}, @var{type})
4229 @defmac BLOCK_REG_PADDING (@var{mode}, @var{type}, @var{first})
4234 @code{MUST_PASS_IN_STACK} need not test padding and mode of types in
4240 @deftypefn {Target Hook} {unsigned int} TARGET_FUNCTION_ARG_BOUNDARY (enum machine_mode @var{mode},…
4242 with the specified mode and type. The default hook returns
4246 …{unsigned int} TARGET_FUNCTION_ARG_ROUND_BOUNDARY (enum machine_mode @var{mode}, const_tree @var{t…
4313 @deftypefn {Target Hook} bool TARGET_VALID_POINTER_MODE (enum machine_mode @var{mode})
4315 with machine mode @var{mode}. The default version of this
4323 @deftypefn {Target Hook} bool TARGET_SCALAR_MODE_SUPPORTED_P (enum machine_mode @var{mode})
4325 insns involving scalar mode @var{mode}. For a scalar mode to be
4329 The default version of this hook returns true for any mode
4335 @deftypefn {Target Hook} bool TARGET_VECTOR_MODE_SUPPORTED_P (enum machine_mode @var{mode})
4337 insns involving vector mode @var{mode}. At the very least, it
4338 must have move patterns for this mode.
4341 @deftypefn {Target Hook} bool TARGET_ARRAY_MODE_SUPPORTED_P (enum machine_mode @var{mode}, unsigned…
4342 Return true if GCC should try to use a scalar mode to store an array
4343 of @var{nelems} elements, given that each element has mode @var{mode}.
4345 and allows GCC to use any defined integer mode.
4364 If this hook allows @code{val} to have a scalar mode, then
4365 @code{int8x8x3_t} can have the same mode. GCC can then store
4369 @deftypefn {Target Hook} bool TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P (enum machine_mode @var{mode…
4372 @var{mode}, the compiler will try to minimize the lifetime of registers
4373 in @var{mode}. The hook may be called with @code{VOIDmode} as argument.
4375 for any mode.
4393 The default version of this hook returns false for any mode. It is always
4427 place regardless of mode.) The value of the expression is usually a
4463 @defmac LIBCALL_VALUE (@var{mode})
4465 function returns a value of mode @var{mode}.
4473 @deftypefn {Target Hook} rtx TARGET_LIBCALL_VALUE (enum machine_mode @var{mode}, const_rtx @var{fun…
4477 The mode of the result is given by @var{mode} and the name of the called
4546 When a function value's mode is @code{BLKmode} (and in some other
4563 Note that values of mode @code{BLKmode} must be explicitly handled
4617 This macro has effect in @option{-fpcc-struct-return} mode, but it does
4618 nothing when you use @option{-freg-struct-return} mode.
4622 This target hook returns the mode to be used when accessing raw return registers in @code{__builtin…
4626 This target hook returns the mode to be used when accessing raw argument registers in @code{__built…
4647 A C expression specifying which mode is required for saving @var{nregs}
4651 will select the smallest suitable mode.
5087 …MING_VARARGS (cumulative_args_t @var{args_so_far}, enum machine_mode @var{mode}, tree @var{type}, …
5098 named arguments. The arguments @var{mode} and @var{type} describe the
5099 last named argument---its machine mode and its data type as a tree node.
5307 @defmac FLOAT_LIB_COMPARE_RETURNS_BOOL (@var{mode}, @var{comparison})
5310 mode @var{mode} will return a boolean, and @var{false} if it will
5439 @deftypefn {Target Hook} bool TARGET_LEGITIMATE_ADDRESS_P (enum machine_mode @var{mode}, rtx @var{x…
5441 address on the target machine for a memory operand of mode @var{mode}.
5487 #define GO_IF_LEGITIMATE_ADDRESS (@var{mode}, @var{x}, @var{label})
5492 address on the target machine for a memory operand of mode @var{mode}.
5528 …get Hook} rtx TARGET_LEGITIMIZE_ADDRESS (rtx @var{x}, rtx @var{oldx}, enum machine_mode @var{mode})
5530 operand of mode @var{mode} and should try to return a valid memory
5549 @defmac LEGITIMIZE_RELOAD_ADDRESS (@var{x}, @var{mode}, @var{opnum}, @var{type}, @var{ind_levels}, …
5551 that needs reloading, with a valid memory address for an operand of mode
5552 @var{mode}. @var{win} will be a C statement label elsewhere in the code.
5600 different meanings depending on the machine mode of the memory
5604 Autoincrement and autodecrement addresses typically have mode-dependent
5606 of the operand being addressed. Some machines have other mode-dependent
5607 addresses. Many RISC machines have no mode-dependent addresses.
5617 different meanings depending on the machine mode of the memory
5621 Autoincrement and autodecrement addresses typically have mode-dependent
5623 of the operand being addressed. Some machines have other mode-dependent
5624 addresses. Many RISC machines have no mode-dependent addresses.
5632 @deftypefn {Target Hook} bool TARGET_LEGITIMATE_CONSTANT_P (enum machine_mode @var{mode}, rtx @var{…
5634 @var{mode}-mode immediate operand on the target machine. You can assume that
5655 @deftypefn {Target Hook} bool TARGET_CANNOT_FORCE_CONST_MEM (enum machine_mode @var{mode}, rtx @var…
5657 should not) be spilled to the constant pool. @var{mode} is the mode
5669 @deftypefn {Target Hook} bool TARGET_USE_BLOCKS_FOR_CONSTANT_P (enum machine_mode @var{mode}, const…
5671 be placed in an @code{object_block} structure. @var{mode} is the mode
5773 …bool TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT (enum machine_mode @var{mode}, const_tree @var{t…
5776 parameter. The vector store/load should be of machine mode @var{mode} and
5781 …arget Hook} {enum machine_mode} TARGET_VECTORIZE_PREFERRED_SIMD_MODE (enum machine_mode @var{mode})
5782 This hook should return the preferred mode for vectorizing scalar
5783 mode @var{mode}. The default is
5791 mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE}.
5850 for every mode. The default value is 0.
5910 Registers used to store the condition code value will usually have a mode
6003 this happens, use the machine mode of the condition code register to
6010 a mode given an operand of a compare. This is needed because the modes
6013 be consistent with the mode used in the patterns; for example to support
6068 @defmac REVERSIBLE_CC_MODE (@var{mode})
6070 comparison whose mode is @var{mode}. If @code{SELECT_CC_MODE}
6071 can ever return @var{mode} for a floating-point inequality comparison,
6072 then @code{REVERSIBLE_CC_MODE (@var{mode})} must be zero.
6084 @defmac REVERSE_CONDITION (@var{code}, @var{mode})
6086 comparison done in CC_MODE @var{mode}. The macro is used only in case
6087 @code{REVERSIBLE_CC_MODE (@var{mode})} is nonzero. Define this macro in case
6118 validly done in more than one mode. On such a system, define this
6119 target hook to take two mode arguments and to return a mode in which
6120 both comparisons may be validly done. If there is no such mode,
6124 same. If they are, it returns that mode. If they are different, it
6160 @defmac REGISTER_MOVE_COST (@var{mode}, @var{from}, @var{to})
6161 A C expression for the cost of moving data of mode @var{mode} from a
6182 @deftypefn {Target Hook} int TARGET_REGISTER_MOVE_COST (enum machine_mode @var{mode}, reg_class_t @…
6183 This target hook should return the cost of moving data of mode @var{mode}
6203 @defmac MEMORY_MOVE_COST (@var{mode}, @var{class}, @var{in})
6204 A C expression for the cost of moving data of mode @var{mode} between a
6230 @deftypefn {Target Hook} int TARGET_MEMORY_MOVE_COST (enum machine_mode @var{mode}, reg_class_t @va…
6231 This target hook should return the cost of moving data of mode @var{mode}
6283 @defmac SLOW_UNALIGNED_ACCESS (@var{mode}, @var{alignment})
6285 @var{mode} and @var{alignment} parameters have a cost many times greater
6378 @defmac USE_LOAD_POST_INCREMENT (@var{mode})
6380 thing to use for a given mode. Defaults to the value of
6384 @defmac USE_LOAD_POST_DECREMENT (@var{mode})
6386 thing to use for a given mode. Defaults to the value of
6390 @defmac USE_LOAD_PRE_INCREMENT (@var{mode})
6392 thing to use for a given mode. Defaults to the value of
6396 @defmac USE_LOAD_PRE_DECREMENT (@var{mode})
6398 thing to use for a given mode. Defaults to the value of
6402 @defmac USE_STORE_POST_INCREMENT (@var{mode})
6404 thing to use for a given mode. Defaults to the value of
6408 @defmac USE_STORE_POST_DECREMENT (@var{mode})
6410 thing to use for a given mode. Defaults to the value of
6414 @defmac USE_STORE_PRE_INCREMENT (@var{mode})
6416 thing to use for a given mode. Defaults to the value of
6420 @defmac USE_STORE_PRE_DECREMENT (@var{mode})
6422 thing to use for a given mode. Defaults to the value of
6470 This hook computes the cost of an addressing mode that contains
6475 true cost of the addressing mode. However, on RISC machines, all
6487 the cost of the addressing mode containing the sum is no higher than
6871 …t Hook} int TARGET_SCHED_REASSOCIATION_WIDTH (unsigned int @var{opc}, enum machine_mode @var{mode})
7127 @deftypefn {Target Hook} {section *} TARGET_ASM_SELECT_RTX_SECTION (enum machine_mode @var{mode}, r…
7128 Return the section into which a constant @var{x}, of mode @var{mode},
7130 constant in RTL@. The argument @var{mode} is redundant except in the
7135 constants in @code{flag_pic} mode in @code{data_section} and everything
7323 comments that will cause GAS to issue errors in NO_APP mode.
7603 @defmac ASM_OUTPUT_SPECIAL_POOL_ENTRY (@var{file}, @var{x}, @var{mode}, @var{align}, @var{labelno},…
7610 output, and @var{mode} is the machine mode (in case @var{x} is a
8630 output of assembler code for @var{insn}, to change the mode of the assembler
8637 template into assembler code, so you can change the assembler mode
8802 mode and flags can be read.
8985 register and its mode are represented in Dwarf in non-contiguous
9445 Define this macro if GCC should produce dwarf version 2 format
9449 Define this to enable the dwarf attribute @code{DW_AT_calling_convention} to
9639 …pefn Macro REAL_VALUE_TYPE REAL_VALUE_ATOF (const char *@var{string}, enum machine_mode @var{mode})
9641 representation for mode @var{mode}. This routine can handle both
9681 @deftypefn Macro REAL_VALUE_TYPE REAL_VALUE_TRUNCATE (REAL_VALUE_TYPE @var{mode}, enum machine_mode…
9682 Truncates the floating point value @var{x} to fit in @var{mode}. The
9685 precision accords with mode @var{mode}.
9694 …ALUE_TYPE @var{x}, HOST_WIDE_INT @var{low}, HOST_WIDE_INT @var{high}, enum machine_mode @var{mode})
9697 value is truncated to fit in mode @var{mode}.
9702 @cindex mode switching
9703 The following macros control mode switching optimizations:
9706 Define this macro if the port needs extra instructions inserted for mode
9717 You can have multiple entities that are mode-switched, and select at run time
9719 return nonzero for any @var{entity} that needs mode-switching.
9730 N refers to an entity that needs mode switching, and specifies the number
9733 zero---determines the integer that is used to refer to the mode-switched
9735 In macros that take mode arguments / yield a mode result, modes are
9736 represented as numbers 0 @dots{} N @minus{} 1. N is used to specify that no mode
9741 @var{entity} is an integer specifying a mode-switched entity. If
9744 @code{NUM_MODES_FOR_MODE_SWITCHING}, to denote the mode that @var{entity} must
9748 @defmac MODE_AFTER (@var{mode}, @var{insn})
9750 mode switching. It determines the mode that an insn results in (if
9751 different from the incoming mode).
9756 mode switching. It should evaluate to an integer, which is a mode that
9763 mode switching. It should evaluate to an integer, which is a mode that
9771 lowest. The value of the macro should be an integer designating a mode
9777 @defmac EMIT_MODE_SET (@var{entity}, @var{mode}, @var{hard_regs_live})
9778 Generate one or more insns to set @var{entity} to @var{mode}.
10237 Define this to return the machine mode to use for pointers to
10244 Define this to return the machine mode to use for addresses in
10250 @deftypefn {Target Hook} bool TARGET_ADDR_SPACE_VALID_POINTER_MODE (enum machine_mode @var{mode}, a…
10252 with machine mode @var{mode} to address space @var{as}. This target
10260 @deftypefn {Target Hook} bool TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P (enum machine_mode @var{mode},…
10261 Define this to return true if @var{exp} is a valid address for mode
10262 @var{mode} in the named address space @var{as}. The @var{strict}
10269 …E_LEGITIMIZE_ADDRESS (rtx @var{x}, rtx @var{oldx}, enum machine_mode @var{mode}, addr_space_t @var…
10271 with mode @var{mode} in the named address space @var{as}. This target
10320 An alias for a machine mode name. This is the machine mode that
10325 Optional: return the preferred mode for an @code{addr_diff_vec}
10360 Define this macro if operations between registers with integral mode
10367 memory in @var{mem_mode}, an integral mode narrower than a word, set the
10383 when the @var{from} mode is @var{mem_mode} and the @var{to} mode is any
10384 integral mode larger than this but not larger than @code{word_mode}.
10387 mode, @code{CANNOT_CHANGE_MODE_CLASS} says that they cannot change to
10388 @code{word_mode}, but that they can change to another integral mode that
10403 …pefn {Target Hook} {unsigned int} TARGET_MIN_DIVISIONS_FOR_RECIP_MUL (enum machine_mode @var{mode})
10408 of mode @var{mode}. The default implementation returns 3 if the machine
10451 … {Target Hook} {unsigned HOST_WIDE_INT} TARGET_SHIFT_TRUNCATION_MASK (enum machine_mode @var{mode})
10452 This function describes how the standard shift patterns for @var{mode}
10453 deal with shifts by negative amounts or by more than the width of the mode.
10459 this is true for mode @var{mode}, the function should return @var{m},
10468 @code{GET_MODE_BITSIZE (@var{mode}) - 1} if @code{SHIFT_COUNT_TRUNCATED}
10491 @deftypefn {Target Hook} int TARGET_MODE_REP_EXTENDED (enum machine_mode @var{mode}, enum machine_m…
10492 The representation of an integral mode can be such that the values
10493 are always extended to a wider integral mode. Return
10494 @code{SIGN_EXTEND} if values of @var{mode} are represented in
10500 @var{mode} to @var{rep_mode} so that @var{rep_mode} is not the next
10501 widest integral mode and currently we take advantage of this fact.)
10510 @code{TARGET_MODE_REP_EXTENDED (mode, word_mode)} you probably also want
10511 to define @code{LOAD_EXTEND_OP (mode)} to return the same type of
10514 In order to enforce the representation of @code{mode},
10516 @code{mode}.
10521 with an integral mode and stored by a store-flag instruction
10522 (@samp{cstore@var{mode}4}) when the condition is true. This description must
10523 apply to @emph{all} the @samp{cstore@var{mode}4} patterns and all the
10524 comparison operators whose results have a @code{MODE_INT} mode.
10530 true. This value is interpreted in the mode of the comparison
10531 operation, which is given by the mode of the first operand in the
10532 @samp{cstore@var{mode}4} pattern. Either the low bit or the sign bit of
10605 @samp{cstore@var{mode}4} insn followed by @code{and} or @code{plus}. On those
10617 @defmac FLOAT_STORE_FLAG_VALUE (@var{mode})
10625 @defmac VECTOR_STORE_FLAG_VALUE (@var{mode})
10628 mode of @var{mode} which is guaranteed to be a vector mode. Define
10634 given mode.
10637 @defmac CLZ_DEFINED_VALUE_AT_ZERO (@var{mode}, @var{value})
10638 @defmacx CTZ_DEFINED_VALUE_AT_ZERO (@var{mode}, @var{value})
10665 An alias for the machine mode for pointers. On most machines, define
10666 this to be the integer mode corresponding to the width of a hardware
10678 An alias for the machine mode used for memory references to functions
10682 size and alignment, this should be a mode with the same size and alignment
10971 …e @var{exp}, rtx @var{target}, rtx @var{subtarget}, enum machine_mode @var{mode}, int @var{ignore})
10976 convenient, and have mode @var{mode} if that is convenient.