Lines Matching refs:MODE
38 /* Define __arm__ even when in thumb mode, for \
249 /* We could use unified syntax for arm mode, but for now we just use it
280 {"mode", "%{!marm:%{!mthumb:-m%(VALUE)}}"},
471 in a wider mode than that declared by the program. In such cases,
473 type, but kept valid in the wider mode. The signedness of the
478 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE) \
479 if (GET_MODE_CLASS (MODE) == MODE_INT \
480 && GET_MODE_SIZE (MODE) < 4) \
482 if (MODE == QImode) \
484 else if (MODE == HImode) \
486 (MODE) = SImode; \
489 #define PROMOTE_FUNCTION_MODE(MODE, UNSIGNEDP, TYPE) \
490 if ((GET_MODE_CLASS (MODE) == MODE_INT \
491 || GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT) \
492 && GET_MODE_SIZE (MODE) < 4) \
493 (MODE) = SImode; \
500 Most ARM processors are run in little endian mode, so that is the default.
507 This is always false, even when in big-endian mode. */
528 #define UNITS_PER_SIMD_WORD(MODE) \
545 /* The lowest bit is used to indicate Thumb-mode functions, so the
875 /* The number of (integer) registers required to hold a quantity of type MODE.
877 #define ARM_NUM_REGS(MODE) \
878 ARM_NUM_INTS (GET_MODE_SIZE (MODE))
880 /* The number of (integer) registers required to hold a quantity of TYPE MODE. */
881 #define ARM_NUM_REGS2(MODE, TYPE) \
882 ARM_NUM_INTS ((MODE) == BLKmode ? \
883 int_size_in_bytes (TYPE) : GET_MODE_SIZE (MODE))
1040 to hold something of mode MODE.
1041 This is ordinarily the length in words of a value of mode MODE
1045 mode. */
1046 #define HARD_REGNO_NREGS(REGNO, MODE) \
1052 ? 1 : ARM_NUM_REGS (MODE))
1054 /* Return true if REGNO is suitable for holding a quantity of type MODE. */
1055 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
1056 arm_hard_regno_mode_ok ((REGNO), (MODE))
1059 when one has mode MODE1 and one has mode MODE2.
1065 #define VALID_IWMMXT_REG_MODE(MODE) \
1066 (arm_vector_mode_supported_p (MODE) || (MODE) == DImode)
1069 #define VALID_NEON_DREG_MODE(MODE) \
1070 ((MODE) == V2SImode || (MODE) == V4HImode || (MODE) == V8QImode \
1071 || (MODE) == V2SFmode || (MODE) == DImode)
1074 #define VALID_NEON_QREG_MODE(MODE) \
1075 ((MODE) == V4SImode || (MODE) == V8HImode || (MODE) == V16QImode \
1076 || (MODE) == V4SFmode || (MODE) == V2DImode)
1079 #define VALID_NEON_STRUCT_MODE(MODE) \
1080 ((MODE) == TImode || (MODE) == EImode || (MODE) == OImode \
1081 || (MODE) == CImode || (MODE) == XImode)
1230 precision. VFP registers may only be accessed in the mode they
1250 when addressing quantities in QI or HI mode; if we don't know the
1251 mode, then we must be conservative. */
1252 #define MODE_BASE_REG_CLASS(MODE) \
1254 (((MODE) == SImode) ? BASE_REGS : LO_REGS))
1258 #define MODE_BASE_REG_REG_CLASS(MODE) BASE_REG_CLASS
1277 #define THUMB_SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \
1280 : (true_regnum (X) + HARD_REGNO_NREGS (0, MODE) > 8) ? LO_REGS \
1284 #define THUMB_SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \
1287 : (true_regnum (X) + HARD_REGNO_NREGS (0, MODE) > 8) ? LO_REGS \
1292 or out of a register in CLASS in MODE. If it can be done directly,
1294 #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \
1298 ? coproc_secondary_reload_class (MODE, X, FALSE) \
1300 ? coproc_secondary_reload_class (MODE, X, TRUE) \
1302 ? (((MODE) == HImode && ! arm_arch4 && true_regnum (X) == -1) \
1304 : THUMB_SECONDARY_OUTPUT_RELOAD_CLASS (CLASS, MODE, X))
1307 #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \
1311 ? coproc_secondary_reload_class (MODE, X, FALSE) : \
1313 coproc_secondary_reload_class (MODE, X, TRUE) : \
1323 (((MODE) == HImode && ! arm_arch4 \
1328 : THUMB_SECONDARY_INPUT_RELOAD_CLASS (CLASS, MODE, X)))
1337 #define ARM_LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND, WIN) \
1343 && REG_MODE_OK_FOR_BASE_P (XEXP (X, 0), MODE) \
1349 if (MODE == DImode || (MODE == DFmode && TARGET_SOFT_FLOAT)) \
1354 else if (MODE == SImode \
1355 || (MODE == SFmode && TARGET_SOFT_FLOAT) \
1356 || ((MODE == HImode || MODE == QImode) && ! arm_arch4)) \
1359 else if ((MODE == HImode || MODE == QImode) && arm_arch4) \
1362 else if (GET_MODE_CLASS (MODE) == MODE_FLOAT \
1383 MODE_BASE_REG_CLASS (MODE), GET_MODE (X), \
1399 #define THUMB_LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND_L, WIN) \
1401 rtx new_x = thumb_legitimize_reload_address (&X, MODE, OPNUM, TYPE, IND_L); \
1409 #define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND_LEVELS, WIN) \
1411 ARM_LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS, WIN); \
1413 THUMB_LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS, WIN)
1416 needed to represent mode MODE in a register of class CLASS.
1417 ARM regs are UNITS_PER_WORD bits while FPA regs can hold any FP mode */
1418 #define CLASS_MAX_NREGS(CLASS, MODE) \
1419 (((CLASS) == FPA_REGS || (CLASS) == CIRRUS_REGS) ? 1 : ARM_NUM_REGS (MODE))
1422 operand of a SUBREG that changes the mode of the object illegally. */
1425 #define REGISTER_MOVE_COST(MODE, FROM, TO) \
1499 assuming the value has mode MODE. */
1500 #define LIBCALL_VALUE(MODE) \
1502 && GET_MODE_CLASS (MODE) == MODE_FLOAT \
1503 ? gen_rtx_REG (MODE, FIRST_FPA_REGNUM) \
1505 && GET_MODE_CLASS (MODE) == MODE_FLOAT \
1506 ? gen_rtx_REG (MODE, FIRST_CIRRUS_FP_REGNUM) \
1507 : TARGET_IWMMXT_ABI && arm_vector_mode_supported_p (MODE) \
1508 ? gen_rtx_REG (MODE, FIRST_IWMMXT_REGNUM) \
1509 : gen_rtx_REG (MODE, ARG_REGISTER (1)))
1578 Only soft_frame is used in thumb mode. */
1644 MODE is the argument's machine mode.
1658 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
1659 arm_function_arg (&(CUM), (MODE), (TYPE), (NAMED))
1661 #define FUNCTION_ARG_PADDING(MODE, TYPE) \
1662 (arm_pad_arg_upward (MODE, TYPE) ? upward : downward)
1664 #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \
1665 (arm_pad_reg_upward (MODE, TYPE, FIRST) ? upward : downward)
1680 of mode MODE and data type TYPE.
1682 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
1684 if (arm_vector_mode_supported_p (MODE) \
1689 (CUM).nregs += ARM_NUM_REGS2 (MODE, TYPE)
1692 argument with the specified mode and type. If it is not defined,
1694 #define FUNCTION_ARG_BOUNDARY(MODE,TYPE) \
1695 ((ARM_DOUBLEWORD_ALIGN && arm_needs_doubleword_align (MODE, TYPE)) \
1852 Unlike 16-bit Thumb, we enter the stub in thumb mode. */
1891 /* Thumb trampolines should be entered in thumb mode, so set the bottom bit
1955 #define THUMB1_REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) \
1957 || (GET_MODE_SIZE (MODE) >= 4 \
1960 #define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) \
1962 ? THUMB1_REGNO_MODE_OK_FOR_BASE_P (REGNO, MODE) \
1965 /* Nonzero if X can be the base register in a reg+reg addressing mode.
1967 #define REGNO_MODE_OK_FOR_REG_BASE_P(X, MODE) \
1970 /* For ARM code, we don't care about the mode, but for Thumb, the index
2124 #define THUMB1_REG_MODE_OK_FOR_BASE_P(X, MODE) \
2127 || (GET_MODE_SIZE (MODE) >= 4 \
2142 #define THUMB1_REG_MODE_OK_FOR_BASE_P(X, MODE) \
2143 THUMB1_REGNO_MODE_OK_FOR_BASE_P (REGNO (X), MODE)
2151 #define REG_MODE_OK_FOR_BASE_P(X, MODE) \
2153 ? THUMB1_REG_MODE_OK_FOR_BASE_P (X, MODE) \
2169 /* Nonzero if X can be the base register in a reg+reg addressing mode.
2171 #define REG_MODE_OK_FOR_REG_BASE_P(X, MODE) \
2177 The MODE argument is the machine mode for the MEM expression
2186 #define ARM_GO_IF_LEGITIMATE_ADDRESS(MODE,X,WIN) \
2188 if (arm_legitimate_address_p (MODE, X, SET, REG_STRICT_P)) \
2192 #define THUMB2_GO_IF_LEGITIMATE_ADDRESS(MODE,X,WIN) \
2194 if (thumb2_legitimate_address_p (MODE, X, REG_STRICT_P)) \
2198 #define THUMB1_GO_IF_LEGITIMATE_ADDRESS(MODE,X,WIN) \
2200 if (thumb1_legitimate_address_p (MODE, X, REG_STRICT_P)) \
2204 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, WIN) \
2206 ARM_GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN) \
2208 THUMB2_GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN) \
2210 THUMB1_GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN)
2216 #define ARM_LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \
2218 X = arm_legitimize_address (X, OLDX, MODE); \
2222 #define THUMB2_LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \
2226 #define THUMB1_LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \
2228 X = thumb_legitimize_address (X, OLDX, MODE); \
2231 #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \
2234 ARM_LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN); \
2236 THUMB2_LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN); \
2238 THUMB1_LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN); \
2240 if (memory_address_p (MODE, X)) \
2245 has an effect that depends on the machine mode it is used for. */
2261 /* Specify the machine mode that this machine uses
2286 on the full register even if a narrower mode is specified. */
2289 /* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD
2293 #define LOAD_EXTEND_OP(MODE) \
2295 ((arm_arch4 || (MODE) == QImode) ? ZERO_EXTEND \
2296 : ((BYTES_BIG_ENDIAN && (MODE) == HImode) ? SIGN_EXTEND : UNKNOWN)))
2301 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
2379 return the mode to be used for the comparison. */
2383 #define REVERSIBLE_CC_MODE(MODE) 1
2385 #define REVERSE_CONDITION(CODE,MODE) \
2386 (((MODE) == CCFPmode || (MODE) == CCFPEmode) \
2406 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1)
2686 when running in 26-bit mode. */
2699 in 26 bit mode, the condition codes must be masked out of the \
2701 when running in 32 bit mode. */ \
