gcc/ChangeLog:
* config/csky/csky.md (CSKY_NPARM_FREGS): New.
(call_value_internal_vs/d): New.
(untyped_call): New.
* config/csky/csky.h (TARGET_SINGLE_FPU): New.
(TARGET_DOUBLE_FPU): New.
(FUNCTION_VARG_REGNO_P): New.
(CSKY_VREG_MODE_P): New.
(FUNCTION_VARG_MODE_P): New.
(CUMULATIVE_ARGS): Add extra regs info.
(INIT_CUMULATIVE_ARGS): Use csky_init_cumulative_args.
(FUNCTION_ARG_REGNO_P): Use FUNCTION_VARG_REGNO_P.
* config/csky/csky-protos.h (csky_init_cumulative_args): Extern.
* config/csky/csky.c (csky_cpu_cpp_builtins): Support
TARGET_HARD_FLOAT_ABI.
(csky_function_arg): Likewise.
(csky_num_arg_regs): Likewise.
(csky_function_arg_advance): Likewise.
(csky_function_value): Likewise.
(csky_libcall_value): Likewise.
(csky_function_value_regno_p): Likewise.
(csky_arg_partial_bytes): Likewise.
(csky_setup_incoming_varargs): Likewise.
(csky_init_cumulative_args): New.
gcc/testsuite/ChangeLog:
* gcc.dg/builtin-apply2.c : Skip if CSKY.
* gcc.dg/torture/stackalign/builtin-apply-2.c : Likewise.
---
gcc/config/csky/csky-protos.h | 2 +
gcc/config/csky/csky.c | 96 +++++++++++++++++++---
gcc/config/csky/csky.h | 34 ++++++--
gcc/config/csky/csky.md | 84 +++++++++++++++++++
gcc/testsuite/gcc.dg/builtin-apply2.c | 2 +-
.../gcc.dg/torture/stackalign/builtin-apply-2.c | 2 +-
6 files changed, 200 insertions(+), 20 deletions(-)
diff --git a/gcc/config/csky/csky-protos.h b/gcc/config/csky/csky-protos.h
index cc1a033..2c02399 100644
--- a/gcc/config/csky/csky-protos.h
+++ b/gcc/config/csky/csky-protos.h
@@ -68,4 +68,6 @@ extern int csky_compute_pushpop_length (rtx *);
extern int csky_default_branch_cost (bool, bool);
extern bool csky_default_logical_op_non_short_circuit (void);
+
+extern void csky_init_cumulative_args (CUMULATIVE_ARGS *, tree, rtx, tree);
#endif /* GCC_CSKY_PROTOS_H */
diff --git a/gcc/config/csky/csky.c b/gcc/config/csky/csky.c
index 7ba3ed3..8463d8f 100644
--- a/gcc/config/csky/csky.c
+++ b/gcc/config/csky/csky.c
@@ -328,6 +328,16 @@ csky_cpu_cpp_builtins (cpp_reader *pfile)
{
builtin_define ("__csky_hard_float__");
builtin_define ("__CSKY_HARD_FLOAT__");
+ if (TARGET_HARD_FLOAT_ABI)
+ {
+ builtin_define ("__csky_hard_float_abi__");
+ builtin_define ("__CSKY_HARD_FLOAT_ABI__");
+ }
+ if (TARGET_SINGLE_FPU)
+ {
+ builtin_define ("__csky_hard_float_fpu_sf__");
+ builtin_define ("__CSKY_HARD_FLOAT_FPU_SF__");
+ }
}
else
{
@@ -1790,9 +1800,22 @@ static rtx
csky_function_arg (cumulative_args_t pcum_v, const function_arg_info &arg)
{
CUMULATIVE_ARGS *pcum = get_cumulative_args (pcum_v);
+ int reg = pcum->reg;
+ machine_mode mode = arg.mode;
- if (*pcum < CSKY_NPARM_REGS)
- return gen_rtx_REG (arg.mode, CSKY_FIRST_PARM_REGNUM + *pcum);
+ if (FUNCTION_VARG_MODE_P(mode)
+ && !pcum->is_stdarg)
+ {
+ reg = pcum->freg;
+
+ if (reg < CSKY_NPARM_FREGS)
+ return gen_rtx_REG (mode, CSKY_FIRST_VFP_REGNUM + reg);
+ else
+ return NULL_RTX;
+ }
+
+ if (reg < CSKY_NPARM_REGS)
+ return gen_rtx_REG (mode, CSKY_FIRST_PARM_REGNUM + reg);
return NULL_RTX;
}
@@ -1802,7 +1825,7 @@ csky_function_arg (cumulative_args_t pcum_v, const
function_arg_info &arg)
MODE and TYPE. */
static int
-csky_num_arg_regs (machine_mode mode, const_tree type)
+csky_num_arg_regs (machine_mode mode, const_tree type, bool is_stdarg)
{
int size;
@@ -1811,6 +1834,14 @@ csky_num_arg_regs (machine_mode mode, const_tree type)
else
size = GET_MODE_SIZE (mode);
+ if (TARGET_HARD_FLOAT_ABI
+ && !is_stdarg)
+ {
+ if (CSKY_VREG_MODE_P(mode)
+ && !TARGET_SINGLE_FPU)
+ return ((CSKY_NUM_WORDS (size) + 1) / 2);
+ }
+
return CSKY_NUM_WORDS (size);
}
@@ -1822,12 +1853,23 @@ csky_function_arg_advance (cumulative_args_t pcum_v,
const function_arg_info &arg)
{
CUMULATIVE_ARGS *pcum = get_cumulative_args (pcum_v);
- int param_size = csky_num_arg_regs (arg.mode, arg.type);
+ int *reg = &pcum->reg;
+ machine_mode mode = arg.mode;
- if (*pcum + param_size > CSKY_NPARM_REGS)
- *pcum = CSKY_NPARM_REGS;
+ int param_size = csky_num_arg_regs (mode, arg.type, pcum->is_stdarg);
+ int param_regs_nums = CSKY_NPARM_REGS;
+
+ if (FUNCTION_VARG_MODE_P(mode)
+ && !pcum->is_stdarg)
+ {
+ reg = &pcum->freg;
+ param_regs_nums = CSKY_NPARM_FREGS;
+ }
+
+ if (*reg + param_size > param_regs_nums)
+ *reg = param_regs_nums;
else
- *pcum += param_size;
+ *reg += param_size;
}
@@ -1843,6 +1885,12 @@ csky_function_value (const_tree type, const_tree func,
mode = TYPE_MODE (type);
size = int_size_in_bytes (type);
+ if (FUNCTION_VARG_MODE_P(mode))
+ {
+ mode = promote_function_mode (type, mode, &unsignedp, func, 1);
+ return gen_rtx_REG (mode, CSKY_FIRST_VFP_REGNUM);
+ }
+
/* Since we promote return types, we must promote the mode here too. */
if (INTEGRAL_TYPE_P (type))
{
@@ -1877,6 +1925,10 @@ static rtx
csky_libcall_value (machine_mode mode,
const_rtx libcall ATTRIBUTE_UNUSED)
{
+ if (FUNCTION_VARG_MODE_P(mode))
+ {
+ return gen_rtx_REG (mode, CSKY_FIRST_VFP_REGNUM);
+ }
return gen_rtx_REG (mode, CSKY_FIRST_RET_REGNUM);
}
@@ -1887,7 +1939,11 @@ csky_libcall_value (machine_mode mode,
static bool
csky_function_value_regno_p (const unsigned int regno)
{
- return (regno == CSKY_FIRST_RET_REGNUM);
+ if (regno == CSKY_FIRST_RET_REGNUM
+ || (TARGET_HARD_FLOAT_ABI
+ && regno == CSKY_FIRST_VFP_REGNUM))
+ return true;
+ return false;
}
@@ -1912,11 +1968,16 @@ static int
csky_arg_partial_bytes (cumulative_args_t pcum_v, const function_arg_info &arg)
{
CUMULATIVE_ARGS *pcum = get_cumulative_args (pcum_v);
- int param_size = csky_num_arg_regs (arg.mode, arg.type);
+ int param_size = csky_num_arg_regs (arg.mode, arg.type, pcum->is_stdarg);
+ int reg = pcum->reg;
+
+ if (FUNCTION_VARG_MODE_P(arg.mode)
+ && !pcum->is_stdarg)
+ return 0;
- if (*pcum < CSKY_NPARM_REGS
- && *pcum + param_size > CSKY_NPARM_REGS)
- return (CSKY_NPARM_REGS - *pcum) * UNITS_PER_WORD;
+ if (reg < CSKY_NPARM_REGS
+ && reg + param_size > CSKY_NPARM_REGS)
+ return (CSKY_NPARM_REGS - reg) * UNITS_PER_WORD;
return 0;
}
@@ -1941,7 +2002,7 @@ csky_setup_incoming_varargs (cumulative_args_t pcum_v,
cfun->machine->uses_anonymous_args = 1;
local_cum = *pcum;
csky_function_arg_advance (local_cum_v, arg);
- regs_to_push = CSKY_NPARM_REGS - local_cum;
+ regs_to_push = CSKY_NPARM_REGS - local_cum.reg;
if (regs_to_push)
*pretend_size = regs_to_push * UNITS_PER_WORD;
}
@@ -6775,6 +6836,15 @@ csky_fixed_condition_code_regs (unsigned int *p1,
unsigned int *p2)
return true;
}
+void
+csky_init_cumulative_args (CUMULATIVE_ARGS *pcum, tree fntype,
+ rtx libname ATTRIBUTE_UNUSED,
+ tree fndecl ATTRIBUTE_UNUSED)
+{
+ memset(pcum, 0, sizeof(*pcum));
+ if (stdarg_p (fntype))
+ pcum->is_stdarg = true;
+}
struct gcc_target targetm = TARGET_INITIALIZER;
diff --git a/gcc/config/csky/csky.h b/gcc/config/csky/csky.h
index 8f4090b..190a668 100644
--- a/gcc/config/csky/csky.h
+++ b/gcc/config/csky/csky.h
@@ -133,6 +133,22 @@
/* Use hardware floating point calling convention. */
#define TARGET_HARD_FLOAT_ABI (csky_float_abi == CSKY_FLOAT_ABI_HARD)
+#define TARGET_SINGLE_FPU (csky_fpu_index == TARGET_FPU_fpv2_sf)
+#define TARGET_DOUBLE_FPU (TARGET_HARD_FLOAT && !TARGET_SINGLE_FPU)
+
+#define FUNCTION_VARG_REGNO_P(REGNO) \
+ (TARGET_HARD_FLOAT_ABI \
+ && IN_RANGE ((REGNO), CSKY_FIRST_VFP_REGNUM, \
+ CSKY_FIRST_VFP_REGNUM + CSKY_NPARM_FREGS - 1))
+
+#define CSKY_VREG_MODE_P(mode) \
+ ((mode) == SFmode || (mode) == DFmode)
+
+#define FUNCTION_VARG_MODE_P(mode) \
+ (TARGET_HARD_FLOAT_ABI \
+ && CSKY_VREG_MODE_P(mode) \
+ && !(mode == DFmode && TARGET_SINGLE_FPU))
+
/* Number of loads/stores handled by ldm/stm. */
#define CSKY_MIN_MULTIPLE_STLD 3
#define CSKY_MAX_MULTIPLE_STLD 12
@@ -360,7 +376,14 @@ extern int csky_arch_isa_features[];
/* A C type for declaring a variable that is used as the first argument of
TARGET_ FUNCTION_ARG and other related values. */
-#define CUMULATIVE_ARGS int
+#if !defined (USED_FOR_TARGET)
+typedef struct
+{
+ int reg;
+ int freg;
+ bool is_stdarg;
+} CUMULATIVE_ARGS;
+#endif
/* Initialize a variable CUM of type CUMULATIVE_ARGS
for a call to a function whose data type is FNTYPE.
@@ -369,15 +392,16 @@ extern int csky_arch_isa_features[];
On CSKY, the offset always starts at 0: the first parm reg is always
the same reg. */
#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
- ((CUM) = 0)
+ csky_init_cumulative_args (&(CUM), (FNTYPE), (LIBNAME), (INDIRECT))
/* True if N is a possible register number for function argument passing.
On the CSKY, r0-r3 are used to pass args.
The int cast is to prevent a complaint about unsigned comparison to
zero, since CSKY_FIRST_PARM_REGNUM is zero. */
-#define FUNCTION_ARG_REGNO_P(REGNO) \
- (((int)(REGNO) >= CSKY_FIRST_PARM_REGNUM) && \
- ((REGNO) < (CSKY_NPARM_REGS + CSKY_FIRST_PARM_REGNUM)))
+#define FUNCTION_ARG_REGNO_P(REGNO) \
+ (((REGNO) >= CSKY_FIRST_PARM_REGNUM \
+ && (REGNO) < (CSKY_NPARM_REGS + CSKY_FIRST_PARM_REGNUM)) \
+ || FUNCTION_VARG_REGNO_P(REGNO))
/* How Large Values Are Returned */
diff --git a/gcc/config/csky/csky.md b/gcc/config/csky/csky.md
index 15f68f9..7f01fbc 100644
--- a/gcc/config/csky/csky.md
+++ b/gcc/config/csky/csky.md
@@ -50,6 +50,7 @@
(CSKY_LAST_EH_RETDATA_REGNUM 1)
(CSKY_EH_STACKADJ_REGNUM 2)
(CSKY_STACKADJUST_REGNUM 4)
+ (CSKY_NPARM_FREGS 4)
])
;; Supported TLS relocations.
@@ -100,6 +101,7 @@
; Support for the eh_return pattern.
VUNSPEC_EH_RETURN
+ VUNSPEC_BLOCKAGE
])
@@ -3310,6 +3312,88 @@
force_reg (Pmode, XEXP (operands[1], 0)));
}")
+;; Call subroutine returning any type.
+
+(define_expand "untyped_call"
+ [(parallel [(call (match_operand 0 "" "")
+ (const_int 0))
+ (match_operand 1 "" "")
+ (match_operand 2 "" "")])]
+ ""
+{
+ int i;
+
+ emit_call_insn (gen_call (operands[0], const0_rtx));
+
+ for (i = 0; i < XVECLEN (operands[2], 0); i++)
+ {
+ rtx set = XVECEXP (operands[2], 0, i);
+ emit_move_insn (SET_DEST (set), SET_SRC (set));
+ }
+
+ /* The optimizer does not know that the call sets the function value
+ registers we stored in the result block. We avoid problems by
+ claiming that all hard registers are used and clobbered at this
+ point. */
+ emit_insn (gen_blockage ());
+
+ DONE;
+})
+
+;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
+;; all of memory. This blocks insns from being moved across this point.
+
+(define_insn "blockage"
+ [(unspec_volatile [(const_int 0)] VUNSPEC_BLOCKAGE)]
+ ""
+ ""
+ [(set_attr "length" "0")])
+
+(define_insn "*call_value_internal_vs"
+ [(set (match_operand:SF 0 "register_operand" "=v,v,v")
+ (call (mem:SI (match_operand:SI 1 "csky_call_address_operand" "b,
r,S"))
+ (match_operand 2 "" "")))
+ (clobber (reg:SI CSKY_LR_REGNUM))]
+ "TARGET_HARD_FLOAT_ABI"
+ "@
+ jsr\t%1
+ jsr\t%1
+ jbsr\t%1"
+ [(set_attr "length" "2,4,4")
+ (set_attr "type" "call_jsr,call_jsr,call")]
+)
+
+(define_insn "*call_value_internal_vd"
+ [(set (match_operand:DF 0 "register_operand" "=v,v,v")
+ (call (mem:SI (match_operand:SI 1 "csky_call_address_operand" "b,
r,S"))
+ (match_operand 2 "" "")))
+ (clobber (reg:SI CSKY_LR_REGNUM))]
+ "TARGET_HARD_FLOAT_ABI && TARGET_DOUBLE_FPU"
+ "@
+ jsr\t%1
+ jsr\t%1
+ jbsr\t%1"
+ [(set_attr "length" "2,4,4")
+ (set_attr "type" "call_jsr,call_jsr,call")]
+)
+
+(define_insn "*call_value_internal_pic_vs"
+ [(set (match_operand:SF 0 "register_operand" "=v")
+ (call (mem:SI (match_operand:SI 1 "csky_unspec_operand" "X"))
+ (match_operand 2 "" "")))
+ (clobber (reg:SI CSKY_LR_REGNUM))]
+ "flag_pic && TARGET_HARD_FLOAT_ABI"
+ "* return csky_output_call (operands, 1);"
+)
+
+(define_insn "*call_value_internal_pic_vd"
+ [(set (match_operand:DF 0 "register_operand" "=v")
+ (call (mem:SI (match_operand:SI 1 "csky_unspec_operand" "X"))
+ (match_operand 2 "" "")))
+ (clobber (reg:SI CSKY_LR_REGNUM))]
+ "flag_pic && TARGET_HARD_FLOAT_ABI && TARGET_DOUBLE_FPU"
+ "* return csky_output_call (operands, 1);"
+)
(define_insn "*call_value_internal"
[(set (match_operand 0 "register_operand" "=r,r,r")
diff --git a/gcc/testsuite/gcc.dg/builtin-apply2.c
b/gcc/testsuite/gcc.dg/builtin-apply2.c
index 06ef24e..9049af5 100644
--- a/gcc/testsuite/gcc.dg/builtin-apply2.c
+++ b/gcc/testsuite/gcc.dg/builtin-apply2.c
@@ -1,7 +1,7 @@
/* { dg-do run } */
/* { dg-require-effective-target untyped_assembly } */
/* { dg-skip-if "Variadic funcs have all args on stack. Normal funcs have args
in registers." { "avr-*-* nds32*-*-* amdgcn-*-*" } } */
-/* { dg-skip-if "Variadic funcs use different argument passing from normal
funcs." { "riscv*-*-* or1k*-*-* msp430-*-* pru-*-*" } } */
+/* { dg-skip-if "Variadic funcs use different argument passing from normal
funcs." { "csky*-*-* riscv*-*-* or1k*-*-* msp430-*-* pru-*-*" } } */
/* { dg-skip-if "Variadic funcs use Base AAPCS. Normal funcs use VFP
variant." { arm*-*-* && arm_hf_eabi } } */
/* PR target/12503 */
diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c
b/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c
index 31585a0..5ec0558 100644
--- a/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c
+++ b/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c
@@ -9,7 +9,7 @@
/* arm_hf_eabi: Variadic funcs use Base AAPCS. Normal funcs use VFP variant.
avr: Variadic funcs don't pass arguments in registers, while normal funcs
do. */
-/* { dg-skip-if "Variadic funcs use different argument passing from normal
funcs" { arm_hf_eabi || { avr-*-* riscv*-*-* or1k*-*-* msp430-*-* amdgcn-*-*
pru-*-* } } } */
+/* { dg-skip-if "Variadic funcs use different argument passing from normal
funcs" { arm_hf_eabi || { csky*-*-* avr-*-* riscv*-*-* or1k*-*-* msp430-*-*
amdgcn-*-* pru-*-* } } } */
/* { dg-skip-if "Variadic funcs have all args on stack. Normal funcs have args
in registers." { nds32*-*-* } { v850*-*-* } } */
/* { dg-require-effective-target untyped_assembly } */
--
1.9.1
