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
874 /* The number of (integer) registers required to hold a quantity of type MODE.
876 #define ARM_NUM_REGS(MODE) \
877 ARM_NUM_INTS (GET_MODE_SIZE (MODE))
879 /* The number of (integer) registers required to hold a quantity of TYPE MODE. */
880 #define ARM_NUM_REGS2(MODE, TYPE) \
881 ARM_NUM_INTS ((MODE) == BLKmode ? \
882 int_size_in_bytes (TYPE) : GET_MODE_SIZE (MODE))
1042 to hold something of mode MODE.
1043 This is ordinarily the length in words of a value of mode MODE
1047 mode. */
1048 #define HARD_REGNO_NREGS(REGNO, MODE) \
1054 ? 1 : ARM_NUM_REGS (MODE))
1056 /* Return true if REGNO is suitable for holding a quantity of type MODE. */
1057 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
1058 arm_hard_regno_mode_ok ((REGNO), (MODE))
1061 when one has mode MODE1 and one has mode MODE2.
1067 #define VALID_IWMMXT_REG_MODE(MODE) \
1068 (arm_vector_mode_supported_p (MODE) || (MODE) == DImode)
1071 #define VALID_NEON_DREG_MODE(MODE) \
1072 ((MODE) == V2SImode || (MODE) == V4HImode || (MODE) == V8QImode \
1073 || (MODE) == V2SFmode || (MODE) == DImode)
1076 #define VALID_NEON_QREG_MODE(MODE) \
1077 ((MODE) == V4SImode || (MODE) == V8HImode || (MODE) == V16QImode \
1078 || (MODE) == V4SFmode || (MODE) == V2DImode)
1081 #define VALID_NEON_STRUCT_MODE(MODE) \
1082 ((MODE) == TImode || (MODE) == EImode || (MODE) == OImode \
1083 || (MODE) == CImode || (MODE) == XImode)
1236 precision. VFP registers may only be accessed in the mode they
1256 when addressing quantities in QI or HI mode; if we don't know the
1257 mode, then we must be conservative. */
1258 #define MODE_BASE_REG_CLASS(MODE) \
1260 (((MODE) == SImode) ? BASE_REGS : LO_REGS))
1264 #define MODE_BASE_REG_REG_CLASS(MODE) BASE_REG_CLASS
1283 #define THUMB_SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \
1286 : (true_regnum (X) + HARD_REGNO_NREGS (0, MODE) > 8) ? LO_REGS \
1290 #define THUMB_SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \
1293 : (true_regnum (X) + HARD_REGNO_NREGS (0, MODE) > 8) ? LO_REGS \
1298 or out of a register in CLASS in MODE. If it can be done directly,
1300 #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \
1304 ? coproc_secondary_reload_class (MODE, X, FALSE) \
1306 ? coproc_secondary_reload_class (MODE, X, TRUE) \
1308 ? (((MODE) == HImode && ! arm_arch4 && true_regnum (X) == -1) \
1310 : THUMB_SECONDARY_OUTPUT_RELOAD_CLASS (CLASS, MODE, X))
1313 #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \
1317 ? coproc_secondary_reload_class (MODE, X, FALSE) : \
1319 coproc_secondary_reload_class (MODE, X, TRUE) : \
1329 (((MODE) == HImode && ! arm_arch4 \
1334 : THUMB_SECONDARY_INPUT_RELOAD_CLASS (CLASS, MODE, X)))
1343 #define ARM_LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND, WIN) \
1349 && REG_MODE_OK_FOR_BASE_P (XEXP (X, 0), MODE) \
1355 if (MODE == DImode || (MODE == DFmode && TARGET_SOFT_FLOAT)) \
1360 else if (MODE == SImode \
1361 || (MODE == SFmode && TARGET_SOFT_FLOAT) \
1362 || ((MODE == HImode || MODE == QImode) && ! arm_arch4)) \
1365 else if ((MODE == HImode || MODE == QImode) && arm_arch4) \
1368 else if (GET_MODE_CLASS (MODE) == MODE_FLOAT \
1389 MODE_BASE_REG_CLASS (MODE), GET_MODE (X), \
1405 #define THUMB_LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND_L, WIN) \
1407 rtx new_x = thumb_legitimize_reload_address (&X, MODE, OPNUM, TYPE, IND_L); \
1415 #define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND_LEVELS, WIN) \
1417 ARM_LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS, WIN); \
1419 THUMB_LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS, WIN)
1422 needed to represent mode MODE in a register of class CLASS.
1423 ARM regs are UNITS_PER_WORD bits while FPA regs can hold any FP mode */
1424 #define CLASS_MAX_NREGS(CLASS, MODE) \
1425 (((CLASS) == FPA_REGS || (CLASS) == CIRRUS_REGS) ? 1 : ARM_NUM_REGS (MODE))
1428 operand of a SUBREG that changes the mode of the object illegally. */
1431 #define REGISTER_MOVE_COST(MODE, FROM, TO) \
1505 assuming the value has mode MODE. */
1506 #define LIBCALL_VALUE(MODE) \
1507 (TARGET_AAPCS_BASED ? aapcs_libcall_value (MODE) \
1509 && GET_MODE_CLASS (MODE) == MODE_FLOAT) \
1510 ? gen_rtx_REG (MODE, FIRST_FPA_REGNUM) \
1512 && GET_MODE_CLASS (MODE) == MODE_FLOAT \
1513 ? gen_rtx_REG (MODE, FIRST_CIRRUS_FP_REGNUM) \
1514 : TARGET_IWMMXT_ABI && arm_vector_mode_supported_p (MODE) \
1515 ? gen_rtx_REG (MODE, FIRST_IWMMXT_REGNUM) \
1516 : gen_rtx_REG (MODE, ARG_REGISTER (1)))
1579 Only soft_frame is used in thumb mode. */
1686 MODE is the argument's machine mode.
1700 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
1701 arm_function_arg (&(CUM), (MODE), (TYPE), (NAMED))
1703 #define FUNCTION_ARG_PADDING(MODE, TYPE) \
1704 (arm_pad_arg_upward (MODE, TYPE) ? upward : downward)
1706 #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \
1707 (arm_pad_reg_upward (MODE, TYPE, FIRST) ? upward : downward)
1722 of mode MODE and data type TYPE.
1724 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
1725 arm_function_arg_advance (&(CUM), (MODE), (TYPE), (NAMED))
1728 argument with the specified mode and type. If it is not defined,
1730 #define FUNCTION_ARG_BOUNDARY(MODE,TYPE) \
1731 ((ARM_DOUBLEWORD_ALIGN && arm_needs_doubleword_align (MODE, TYPE)) \
1890 Unlike 16-bit Thumb, we enter the stub in thumb mode. */
1929 /* Thumb trampolines should be entered in thumb mode, so set the bottom bit
1993 #define THUMB1_REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) \
1995 || (GET_MODE_SIZE (MODE) >= 4 \
1998 #define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) \
2000 ? THUMB1_REGNO_MODE_OK_FOR_BASE_P (REGNO, MODE) \
2003 /* Nonzero if X can be the base register in a reg+reg addressing mode.
2005 #define REGNO_MODE_OK_FOR_REG_BASE_P(X, MODE) \
2008 /* For ARM code, we don't care about the mode, but for Thumb, the index
2162 #define THUMB1_REG_MODE_OK_FOR_BASE_P(X, MODE) \
2165 || (GET_MODE_SIZE (MODE) >= 4 \
2180 #define THUMB1_REG_MODE_OK_FOR_BASE_P(X, MODE) \
2181 THUMB1_REGNO_MODE_OK_FOR_BASE_P (REGNO (X), MODE)
2189 #define REG_MODE_OK_FOR_BASE_P(X, MODE) \
2191 ? THUMB1_REG_MODE_OK_FOR_BASE_P (X, MODE) \
2207 /* Nonzero if X can be the base register in a reg+reg addressing mode.
2209 #define REG_MODE_OK_FOR_REG_BASE_P(X, MODE) \
2215 The MODE argument is the machine mode for the MEM expression
2224 #define ARM_GO_IF_LEGITIMATE_ADDRESS(MODE,X,WIN) \
2226 if (arm_legitimate_address_p (MODE, X, SET, REG_STRICT_P)) \
2230 #define THUMB2_GO_IF_LEGITIMATE_ADDRESS(MODE,X,WIN) \
2232 if (thumb2_legitimate_address_p (MODE, X, REG_STRICT_P)) \
2236 #define THUMB1_GO_IF_LEGITIMATE_ADDRESS(MODE,X,WIN) \
2238 if (thumb1_legitimate_address_p (MODE, X, REG_STRICT_P)) \
2242 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, WIN) \
2244 ARM_GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN) \
2246 THUMB2_GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN) \
2248 THUMB1_GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN)
2254 #define ARM_LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \
2256 X = arm_legitimize_address (X, OLDX, MODE); \
2260 #define THUMB2_LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \
2264 #define THUMB1_LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \
2266 X = thumb_legitimize_address (X, OLDX, MODE); \
2269 #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \
2272 ARM_LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN); \
2274 THUMB2_LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN); \
2276 THUMB1_LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN); \
2278 if (memory_address_p (MODE, X)) \
2283 has an effect that depends on the machine mode it is used for. */
2299 /* Specify the machine mode that this machine uses
2324 on the full register even if a narrower mode is specified. */
2327 /* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD
2331 #define LOAD_EXTEND_OP(MODE) \
2333 ((arm_arch4 || (MODE) == QImode) ? ZERO_EXTEND \
2334 : ((BYTES_BIG_ENDIAN && (MODE) == HImode) ? SIGN_EXTEND : UNKNOWN)))
2339 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
2417 return the mode to be used for the comparison. */
2421 #define REVERSIBLE_CC_MODE(MODE) 1
2423 #define REVERSE_CONDITION(CODE,MODE) \
2424 (((MODE) == CCFPmode || (MODE) == CCFPEmode) \
2444 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1)
2724 when running in 26-bit mode. */
2737 in 26 bit mode, the condition codes must be masked out of the \
2739 when running in 32 bit mode. */ \
