Lines Matching defs:mode
283 enum machine_mode mode;
287 &mode, &unsignedp, &volatilep, true);
458 c_readstr (const char *str, enum machine_mode mode)
464 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
469 for (i = 0; i < GET_MODE_SIZE (mode); i++)
473 j = GET_MODE_SIZE (mode) - i - 1;
475 && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
484 return immed_double_const (c[0], c[1], mode);
919 sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
1007 insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1140 gives a mode used to copy the register's value. VOIDmode indicates
1147 a mode used to copy the register's value. VOIDmode indicates the
1168 enum machine_mode mode;
1184 mode = reg_raw_mode[regno];
1186 gcc_assert (mode != VOIDmode);
1188 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1192 size += GET_MODE_SIZE (mode);
1193 apply_args_mode[regno] = mode;
1212 enum machine_mode mode;
1222 mode = reg_raw_mode[regno];
1224 gcc_assert (mode != VOIDmode);
1226 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1229 size += GET_MODE_SIZE (mode);
1230 apply_result_mode[regno] = mode;
1253 enum machine_mode mode;
1259 if ((mode = apply_result_mode[regno]) != VOIDmode)
1261 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1264 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1265 mem = adjust_address (result, mode, size);
1269 size += GET_MODE_SIZE (mode);
1283 enum machine_mode mode;
1297 if ((mode = apply_args_mode[regno]) != VOIDmode)
1299 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1303 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1305 emit_move_insn (adjust_address (registers, mode, size), tem);
1306 size += GET_MODE_SIZE (mode);
1382 enum machine_mode mode;
1444 if ((mode = apply_args_mode[regno]) != VOIDmode)
1446 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1449 reg = gen_rtx_REG (mode, regno);
1450 emit_move_insn (reg, adjust_address (arguments, mode, size));
1452 size += GET_MODE_SIZE (mode);
1494 if ((mode = apply_result_mode[regno]) != VOIDmode)
1498 valreg = gen_rtx_REG (mode, regno);
1537 enum machine_mode mode;
1558 if ((mode = apply_result_mode[regno]) != VOIDmode)
1560 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1563 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1564 emit_move_insn (reg, adjust_address (result, mode, size));
1570 size += GET_MODE_SIZE (mode);
1622 appropriate for a given type mode. The `F' and `L' cases are
1783 enum machine_mode mode;
1847 mode = TYPE_MODE (TREE_TYPE (exp));
1849 if (! flag_errno_math || ! HONOR_NANS (mode))
1853 if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
1855 target = gen_reg_rtx (mode);
1874 target = expand_unop (mode, builtin_optab, op0, target, 0);
1921 /* Check operand is a register with expected mode. */
1924 && GET_MODE (operand) == mode)
1927 rtx equiv = gen_rtx_SQRT (mode, operand);
1956 enum machine_mode mode;
1988 mode = TYPE_MODE (TREE_TYPE (exp));
1991 if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
1994 target = gen_reg_rtx (mode);
1996 if (! flag_errno_math || ! HONOR_NANS (mode))
2030 target = expand_binop (mode, builtin_optab, op0, op1,
2067 enum machine_mode mode;
2085 mode = TYPE_MODE (TREE_TYPE (exp));
2089 if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing) {
2102 if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2104 target = gen_reg_rtx (mode);
2142 target = expand_unop (mode, builtin_optab, op0, target, 0);
2175 enum machine_mode mode;
2188 mode = TYPE_MODE (TREE_TYPE (arg));
2191 if (sincos_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
2194 target1 = gen_reg_rtx (mode);
2195 target2 = gen_reg_rtx (mode);
2229 enum machine_mode mode;
2256 mode = TYPE_MODE (TREE_TYPE (exp));
2259 if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2261 target = gen_reg_rtx (mode);
2280 target = expand_unop (mode, builtin_optab, op0, target, 0);
2307 target = gen_reg_rtx (mode);
2449 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2452 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2463 target = gen_reg_rtx (mode);
2466 op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2467 op1 = expand_powi_1 (mode, powi_table[n], cache);
2471 target = gen_reg_rtx (mode);
2473 op0 = expand_powi_1 (mode, n - digit, cache);
2474 op1 = expand_powi_1 (mode, digit, cache);
2478 target = gen_reg_rtx (mode);
2479 op0 = expand_powi_1 (mode, n >> 1, cache);
2483 result = expand_mult (mode, op0, op1, target, 0);
2489 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2490 floating point operand in mode MODE, and N is the exponent. This
2494 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2501 return CONST1_RTX (mode);
2508 result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2512 result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2555 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2557 op = force_reg (mode, op);
2558 return expand_powi (op, mode, n);
2579 enum machine_mode mode;
2587 mode = TYPE_MODE (TREE_TYPE (exp));
2605 op0 = force_reg (mode, op0);
2606 return expand_powi (op0, mode, n);
2616 target = gen_reg_rtx (mode);
2618 op0 = expand_expr (arg0, subtarget, mode, 0);
2619 if (GET_MODE (op0) != mode)
2620 op0 = convert_to_mode (mode, op0, 0);
2625 target = emit_library_call_value (powi_optab->handlers[(int) mode].libfunc,
2626 target, LCT_CONST_MAKE_BLOCK, mode, 2,
2627 op0, mode, op1, mode2);
2674 /* Bail out if we can't compute strlen in the right mode. */
2704 char_mode = insn_data[(int) icode].operand[2].mode;
2728 /* Return the value in the proper mode for this function. */
2742 in TARGET, if convenient (and in mode MODE if that's convenient). */
2745 expand_builtin_strstr (tree arglist, tree type, rtx target, enum machine_mode mode)
2751 return expand_expr (result, target, mode, EXPAND_NORMAL);
2758 in TARGET, if convenient (and in mode MODE if that's convenient). */
2761 expand_builtin_strchr (tree arglist, tree type, rtx target, enum machine_mode mode)
2767 return expand_expr (result, target, mode, EXPAND_NORMAL);
2776 in TARGET, if convenient (and in mode MODE if that's convenient). */
2779 expand_builtin_strrchr (tree arglist, tree type, rtx target, enum machine_mode mode)
2785 return expand_expr (result, target, mode, EXPAND_NORMAL);
2792 in TARGET, if convenient (and in mode MODE if that's convenient). */
2795 expand_builtin_strpbrk (tree arglist, tree type, rtx target, enum machine_mode mode)
2801 return expand_expr (result, target, mode, EXPAND_NORMAL);
2812 enum machine_mode mode)
2817 && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
2820 return c_readstr (str + offset, mode);
2826 mode MODE if that's convenient). */
2828 expand_builtin_memcpy (tree exp, rtx target, enum machine_mode mode)
2856 return expand_expr (result, target, mode, EXPAND_NORMAL);
2910 mode MODE if that's convenient). If ENDP is 0 return the
2916 expand_builtin_mempcpy (tree arglist, tree type, rtx target, enum machine_mode mode,
2931 target, mode, EXPAND_NORMAL);
2953 return expand_expr (result, target, mode, EXPAND_NORMAL);
3011 enum machine_mode mode, tree orig_exp)
3035 return expand_expr (result, target, mode, EXPAND_NORMAL);
3057 return expand_expr (fn, target, mode, EXPAND_NORMAL);
3070 rtx ret = expand_builtin_mempcpy (arglist, type, target, mode,
3160 if (data->operand[0].mode != VOIDmode)
3161 end = gen_lowpart (data->operand[0].mode, end);
3183 the result in TARGET, if convenient (and in mode MODE if that's
3187 expand_builtin_strcpy (tree fndecl, tree arglist, rtx target, enum machine_mode mode)
3200 return expand_expr (result, target, mode, EXPAND_NORMAL);
3213 mode MODE if that's convenient). */
3216 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3229 target, mode, EXPAND_NORMAL);
3256 target, mode, /*endp=*/2);
3268 arglist, target, mode);
3274 if (mode != VOIDmode)
3275 target = gen_reg_rtx (mode);
3303 enum machine_mode mode)
3310 return c_readstr (str + offset, mode);
3317 expand_builtin_strncpy (tree exp, rtx target, enum machine_mode mode)
3336 return expand_expr (result, target, mode, EXPAND_NORMAL);
3380 enum machine_mode mode)
3383 char *p = alloca (GET_MODE_SIZE (mode));
3385 memset (p, *c, GET_MODE_SIZE (mode));
3387 return c_readstr (p, mode);
3392 char value given in the RTL register data. For example, if mode is
3397 enum machine_mode mode)
3403 size = GET_MODE_SIZE (mode);
3409 coeff = c_readstr (p, mode);
3411 target = convert_to_mode (mode, (rtx) data, 1);
3412 target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3413 return force_reg (mode, target);
3418 the result in TARGET, if convenient (and in mode MODE if that's
3422 expand_builtin_memset (tree arglist, rtx target, enum machine_mode mode,
3451 return expand_expr (dest, target, mode, EXPAND_NORMAL);
3571 TARGET, if convenient (and in mode MODE, if that's convenient). */
3575 enum machine_mode mode)
3584 return expand_expr (result, target, mode, EXPAND_NORMAL);
3604 insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
3609 insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3661 /* Return the value in the proper mode for this function. */
3662 mode = TYPE_MODE (TREE_TYPE (exp));
3663 if (GET_MODE (result) == mode)
3671 return convert_to_mode (mode, result, 0);
3683 expand_builtin_strcmp (tree exp, rtx target, enum machine_mode mode)
3693 return expand_expr (result, target, mode, EXPAND_NORMAL);
3727 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3748 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3803 /* Return the value in the proper mode for this function. */
3804 mode = TYPE_MODE (TREE_TYPE (exp));
3805 if (GET_MODE (result) == mode)
3808 return convert_to_mode (mode, result, 0);
3835 expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode)
3846 return expand_expr (result, target, mode, EXPAND_NORMAL);
3868 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3935 /* Return the value in the proper mode for this function. */
3936 mode = TYPE_MODE (TREE_TYPE (exp));
3937 if (GET_MODE (result) == mode)
3940 return convert_to_mode (mode, result, 0);
3965 expand_builtin_strcat (tree fndecl, tree arglist, rtx target, enum machine_mode mode)
3977 return expand_expr (dst, target, mode, EXPAND_NORMAL);
4008 if (!expand_builtin_strcpy (fndecl, arglist, target, mode))
4019 return expand_expr (dst, target, mode, EXPAND_NORMAL);
4031 expand_builtin_strncat (tree arglist, rtx target, enum machine_mode mode)
4038 return expand_expr (result, target, mode, EXPAND_NORMAL);
4048 expand_builtin_strspn (tree arglist, rtx target, enum machine_mode mode)
4054 return expand_expr (result, target, mode, EXPAND_NORMAL);
4064 expand_builtin_strcspn (tree arglist, rtx target, enum machine_mode mode)
4070 return expand_expr (result, target, mode, EXPAND_NORMAL);
4430 mode of the result comes out right. */
4825 enum machine_mode mode;
4833 mode = TYPE_MODE (TREE_TYPE (arg));
4835 return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4889 TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
4892 expand_builtin_printf (tree exp, rtx target, enum machine_mode mode,
4993 return expand_expr (fn, target, mode, EXPAND_NORMAL);
4999 TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
5002 expand_builtin_fprintf (tree exp, rtx target, enum machine_mode mode,
5095 return expand_expr (fn, target, mode, EXPAND_NORMAL);
5101 mode MODE. */
5104 expand_builtin_sprintf (tree arglist, rtx target, enum machine_mode mode)
5148 return expand_expr (exp, target, mode, EXPAND_NORMAL);
5183 return expand_expr (len, target, mode, EXPAND_NORMAL);
5355 /* If the bitpos is within the "result mode" lowpart, the operation
5381 significant bit, then truncate the result to the desired mode
5460 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5462 casts. The mode computed in expand_builtin isn't reliable either, due
5466 group of builtins. This gives us log2 of the mode size. */
5480 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5489 mem = validize_mem (gen_rtx_MEM (mode, addr));
5507 expand_builtin_sync_operation (enum machine_mode mode, tree arglist,
5515 mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
5518 val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
5519 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5524 val = convert_modes (mode, old_mode, val, 1);
5538 expand_builtin_compare_and_swap (enum machine_mode mode, tree arglist,
5545 mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
5548 old_val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
5549 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5554 old_val = convert_modes (mode, old_mode, old_val, 1);
5557 new_val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
5558 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5563 new_val = convert_modes (mode, old_mode, new_val, 1);
5578 expand_builtin_lock_test_and_set (enum machine_mode mode, tree arglist,
5585 mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
5588 val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
5589 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5594 val = convert_modes (mode, old_mode, val, 1);
5626 expand_builtin_lock_release (enum machine_mode mode, tree arglist)
5633 mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
5636 icode = sync_lock_release[mode];
5639 if (!insn_data[icode].operand[1].predicate (val, mode))
5640 val = force_reg (mode, val);
5659 (and in mode MODE if that's convenient).
5664 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5673 return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5946 target = expand_builtin_strcpy (fndecl, arglist, target, mode);
5953 target = expand_builtin_strncpy (exp, target, mode);
5960 target = expand_builtin_stpcpy (exp, target, mode);
5968 target = expand_builtin_strcat (fndecl, arglist, target, mode);
5975 target = expand_builtin_strncat (arglist, target, mode);
5981 target = expand_builtin_strspn (arglist, target, mode);
5987 target = expand_builtin_strcspn (arglist, target, mode);
5993 target = expand_builtin_strstr (arglist, TREE_TYPE (exp), target, mode);
5999 target = expand_builtin_strpbrk (arglist, TREE_TYPE (exp), target, mode);
6006 target = expand_builtin_strchr (arglist, TREE_TYPE (exp), target, mode);
6013 target = expand_builtin_strrchr (arglist, TREE_TYPE (exp), target, mode);
6019 target = expand_builtin_memcpy (exp, target, mode);
6025 target = expand_builtin_mempcpy (arglist, TREE_TYPE (exp), target, mode, /*endp=*/ 1);
6032 mode, exp);
6044 target = expand_builtin_memset (arglist, target, mode, exp);
6056 target = expand_builtin_strcmp (exp, target, mode);
6062 target = expand_builtin_strncmp (exp, target, mode);
6069 target = expand_builtin_memcmp (exp, arglist, target, mode);
6172 target = expand_builtin_printf (exp, target, mode, false);
6178 target = expand_builtin_printf (exp, target, mode, true);
6195 target = expand_builtin_fprintf (exp, target, mode, false);
6201 target = expand_builtin_fprintf (exp, target, mode, true);
6208 target = expand_builtin_sprintf (arglist, target, mode);
6288 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6289 target = expand_builtin_sync_operation (mode, arglist, PLUS,
6300 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6301 target = expand_builtin_sync_operation (mode, arglist, MINUS,
6312 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6313 target = expand_builtin_sync_operation (mode, arglist, IOR,
6324 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6325 target = expand_builtin_sync_operation (mode, arglist, AND,
6336 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6337 target = expand_builtin_sync_operation (mode, arglist, XOR,
6348 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6349 target = expand_builtin_sync_operation (mode, arglist, NOT,
6360 mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6361 target = expand_builtin_sync_operation (mode, arglist, PLUS,
6372 mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6373 target = expand_builtin_sync_operation (mode, arglist, MINUS,
6384 mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6385 target = expand_builtin_sync_operation (mode, arglist, IOR,
6396 mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6397 target = expand_builtin_sync_operation (mode, arglist, AND,
6408 mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6409 target = expand_builtin_sync_operation (mode, arglist, XOR,
6420 mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6421 target = expand_builtin_sync_operation (mode, arglist, NOT,
6432 if (mode == VOIDmode)
6433 mode = TYPE_MODE (boolean_type_node);
6434 if (!target || !register_operand (target, mode))
6435 target = gen_reg_rtx (mode);
6437 mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6438 target = expand_builtin_compare_and_swap (mode, arglist, true, target);
6448 mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6449 target = expand_builtin_compare_and_swap (mode, arglist, false, target);
6459 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6460 target = expand_builtin_lock_test_and_set (mode, arglist, target);
6470 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6471 expand_builtin_lock_release (mode, arglist);
6485 target = expand_builtin_memory_chk (exp, target, mode, fcode);
9294 enum machine_mode mode ATTRIBUTE_UNUSED,
10074 mode MODE if that's convenient). */
10077 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
10141 return expand_expr (fn, target, mode, EXPAND_NORMAL);
10163 return expand_expr (dest, target, mode, EXPAND_NORMAL);
10168 return expand_expr (expr, target, mode, EXPAND_NORMAL);
10190 return expand_expr (fn, target, mode, EXPAND_NORMAL);