From patchwork Fri Dec 15 08:57:31 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Xi Ruoyao X-Patchwork-Id: 179117 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:7300:3b04:b0:fb:cd0c:d3e with SMTP id c4csp9135379dys; Fri, 15 Dec 2023 01:03:10 -0800 (PST) X-Google-Smtp-Source: AGHT+IEbF/bP9L7nLQL5j/fJGVzerSqFEo7r31QoJDIwmoFpG35pb1kTpvcS5cNX4qzwGqHJOpI2 X-Received: by 2002:a05:6870:331f:b0:203:4de4:2601 with SMTP id x31-20020a056870331f00b002034de42601mr2137049oae.114.1702630989925; Fri, 15 Dec 2023 01:03:09 -0800 (PST) ARC-Seal: i=2; a=rsa-sha256; t=1702630989; cv=pass; d=google.com; s=arc-20160816; b=vILc7z7mWgECknEUTDmlvqDVQkjnVBn+X8CX05j2wvhBlJ660ltlPNe36sh0jc1ImY xOiEkYxy9zIdEJOpYuZD+iuvYXQtzHo2OaECzMzonVx1CgAGBYf5qiOi+6RmH4G24al0 afdIPpwYRO9Zn14fjouUnIktP1ByhEBCapfjOVmScpSQpaVzpfzuKjstfNs3+BzwCa0r iXMrC4Ezv/lrn3X16HaP63uTrU8XYmbQ8I8FvYctYOmKZOQUmmD3k0oC5GzQPO0uqtgK Yxvp+0tG/x6JZQ8fBXmlDQ/3rP5H0TzG1r9gBo8j03lgWBffvyMPd5+8IG9+khpFGg9r WS8w== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:message-id:date:subject:cc:to:from:dkim-signature :arc-filter:dmarc-filter:delivered-to; bh=haTpksVVtWid2G6sJzFEvzg/1MH2cNoXFa+2oGCWLbY=; fh=h9vDqAKzWjaBKN1vbTfWgOFL71jbM9iMgy2hu3zgT2o=; b=LYl91WHFJ1HwZT3mXqFe4r5m1/LHxdOd0WwMb8ck/JVp1BS8cbTEVhjqrBm2hgVSZT fErlpOkB4R61yWAhumh97QCC0cj/+LH5U/eBVr7s3tXQIINRdJH0/kLXF83P6RMrJzYo I4/YcXIf+mBXErofM+lGIaE4DfMgTG1zKHMMux7LHPggkNGY5MeufLi6Avgg8ByA3IYc pGZDLz73HheK4MX9lItIrgwH+LO8h+Fi1GMM1jBvpmPr0oBdQLbDucpn/a9WZAt4iPIP YbFUg9S0QX8VwJbhWora7V0u6PnAxRFij1YS016nOLJ18T5le1LKYnH/GsxTpU84CuKj 6kcw== ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@xry111.site header.s=default header.b=Kb4Jfp9i; arc=pass (i=1); spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=xry111.site Received: from server2.sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id kb12-20020a05622a448c00b0042372a5a7c9si15329047qtb.154.2023.12.15.01.03.09 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 15 Dec 2023 01:03:09 -0800 (PST) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@xry111.site header.s=default header.b=Kb4Jfp9i; arc=pass (i=1); spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=xry111.site Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 9EC303860763 for ; Fri, 15 Dec 2023 09:03:09 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from xry111.site (xry111.site [89.208.246.23]) by sourceware.org (Postfix) with ESMTPS id 5C6263860763 for ; Fri, 15 Dec 2023 09:02:41 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 5C6263860763 Authentication-Results: sourceware.org; dmarc=pass (p=reject dis=none) header.from=xry111.site Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=xry111.site ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 5C6263860763 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=89.208.246.23 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1702630964; cv=none; b=BfLT3LSOjaxHTSxa9ZnG5MD1INDxmLhgFE3Q3+IFXo6mKlmTViVAyfVCWcR+EdvqoCXGiLe3/7ncz9w2dZC7JZgPz69GR3HUhIBRSd+Ou3zPKNz0rUSo8ccnZjLdw1xGbPaM5qc8xnUmD8GVH/TVGI+Do8/3TQ792Gaq9iQQ5fg= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1702630964; c=relaxed/simple; bh=/StpJqL28gJOqCZZdue81D6NcjkRM1BRL3cw3Z/N2KM=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=G6+hK1Xph/cAYv6PrGLFYyeN7KcROuj8Vyjp334ZIALe4zYaiTvlx+CVf/Dpfyt9Hik3L7KSMPxZvXxbrn8jZKRVAsa5rFubENr9shpcEituF2qQ9PBpCXbLlOZpQNZxqzWNlZeUA36N5G3dSsVBOOrvOnYmgIVj4i6+qIKMaNM= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=xry111.site; s=default; t=1702630957; bh=/StpJqL28gJOqCZZdue81D6NcjkRM1BRL3cw3Z/N2KM=; h=From:To:Cc:Subject:Date:From; b=Kb4Jfp9iW7Ye3eQDHmdaARsb4XcbFmy/aP8drGa/JPlWVfyKAKU+79nYepYu4S6En u3MyjECA/QfTNMkHCriR0kS3FoevM+iju8FjHnTh/iw8W4S7Gyc2T2H1ca/OUgBT8M q7Nhcmg84wF4Vv7UCwOXVtJ62AxQWg/wpzWro+Vg= Received: from stargazer.. (unknown [IPv6:240e:358:1136:1400:dc73:854d:832e:2]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-384) server-digest SHA384) (Client did not present a certificate) (Authenticated sender: xry111@xry111.site) by xry111.site (Postfix) with ESMTPSA id 30B8C66AE2; Fri, 15 Dec 2023 04:02:33 -0500 (EST) From: Xi Ruoyao To: gcc-patches@gcc.gnu.org Cc: chenglulu , i@xen0n.name, xuchenghua@loongson.cn, Jiahao Xu , Xi Ruoyao Subject: [PATCH v2] LoongArch: Implement FCCmode reload and cstore4 Date: Fri, 15 Dec 2023 16:57:31 +0800 Message-ID: <20231215090223.3311-1-xry111@xry111.site> X-Mailer: git-send-email 2.43.0 MIME-Version: 1.0 X-Spam-Status: No, score=-8.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_NUMSUBJECT, KAM_SHORT, LIKELY_SPAM_FROM, SPF_HELO_PASS, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1785337993027456079 X-GMAIL-MSGID: 1785337993027456079 We used a branch to load floating-point comparison results into GPR. This is very slow when the branch is not predictable. Implement movfcc so we can reload FCCmode into GPRs, FPRs, and MEM. Then implement cstore4. gcc/ChangeLog: * config/loongarch/loongarch-tune.h (loongarch_rtx_cost_data::movcf2gr): New field. (loongarch_rtx_cost_data::movcf2gr_): New method. (loongarch_rtx_cost_data::use_movcf2gr): New method. * config/loongarch/loongarch-def.cc (loongarch_rtx_cost_data::loongarch_rtx_cost_data): Set movcf2gr to COSTS_N_INSNS (7) and movgr2cf to COSTS_N_INSNS (15), based on timing on LA464. (loongarch_cpu_rtx_cost_data): Set movcf2gr and movgr2cf to COSTS_N_INSNS (1) for LA664. (loongarch_rtx_cost_optimize_size): Set movcf2gr and movgr2cf to COSTS_N_INSNS (1) + 1. * config/loongarch/predicates.md (loongarch_fcmp_operator): New predicate. * config/loongarch/loongarch.md (movfcc): Change to define_expand. (movfcc_internal): New define_insn. (fcc_to_): New define_insn. (cstore4): New define_expand. * config/loongarch/loongarch.cc (loongarch_hard_regno_mode_ok_uncached): Allow FCCmode in GPRs and GPRs. (loongarch_secondary_reload): Reload FCCmode via FPR and/or GPR. (loongarch_emit_float_compare): Call gen_reg_rtx instead of loongarch_allocate_fcc. (loongarch_allocate_fcc): Remove. (loongarch_move_to_gpr_cost): Handle FCC_REGS -> GR_REGS. (loongarch_move_from_gpr_cost): Handle GR_REGS -> FCC_REGS. (loongarch_register_move_cost): Handle FCC_REGS -> FCC_REGS, FCC_REGS -> FP_REGS, and FP_REGS -> FCC_REGS. gcc/testsuite/ChangeLog: * gcc.target/loongarch/movcf2gr.c: New test. * gcc.target/loongarch/movcf2gr-via-fr.c: New test. --- Superseds https://gcc.gnu.org/pipermail/gcc-patches/2023-December/640497.html. Bootstrapped and regtested on loongarch64-linux-gnu. Ok for trunk? gcc/config/loongarch/loongarch-def.cc | 13 +++- gcc/config/loongarch/loongarch-tune.h | 15 +++- gcc/config/loongarch/loongarch.cc | 70 ++++++++++++------- gcc/config/loongarch/loongarch.md | 69 ++++++++++++++++-- gcc/config/loongarch/predicates.md | 4 ++ .../gcc.target/loongarch/movcf2gr-via-fr.c | 10 +++ gcc/testsuite/gcc.target/loongarch/movcf2gr.c | 9 +++ 7 files changed, 157 insertions(+), 33 deletions(-) create mode 100644 gcc/testsuite/gcc.target/loongarch/movcf2gr-via-fr.c create mode 100644 gcc/testsuite/gcc.target/loongarch/movcf2gr.c diff --git a/gcc/config/loongarch/loongarch-def.cc b/gcc/config/loongarch/loongarch-def.cc index 4a8885e8343..843be78e46e 100644 --- a/gcc/config/loongarch/loongarch-def.cc +++ b/gcc/config/loongarch/loongarch-def.cc @@ -101,15 +101,21 @@ loongarch_rtx_cost_data::loongarch_rtx_cost_data () int_mult_di (COSTS_N_INSNS (4)), int_div_si (COSTS_N_INSNS (5)), int_div_di (COSTS_N_INSNS (5)), + movcf2gr (COSTS_N_INSNS (7)), + movgr2cf (COSTS_N_INSNS (15)), branch_cost (6), memory_latency (4) {} /* The following properties cannot be looked up directly using "cpucfg". So it is necessary to provide a default value for "unknown native" tune targets (i.e. -mtune=native while PRID does not correspond to - any known "-mtune" type). Currently all numbers are default. */ + any known "-mtune" type). */ array_tune loongarch_cpu_rtx_cost_data = - array_tune (); + array_tune () + .set (CPU_LA664, + loongarch_rtx_cost_data () + .movcf2gr_ (COSTS_N_INSNS (1)) + .movgr2cf_ (COSTS_N_INSNS (1))); /* RTX costs to use when optimizing for size. We use a value slightly larger than COSTS_N_INSNS (1) for all of them @@ -125,7 +131,8 @@ const loongarch_rtx_cost_data loongarch_rtx_cost_optimize_size = .int_mult_si_ (COST_COMPLEX_INSN) .int_mult_di_ (COST_COMPLEX_INSN) .int_div_si_ (COST_COMPLEX_INSN) - .int_div_di_ (COST_COMPLEX_INSN); + .int_div_di_ (COST_COMPLEX_INSN) + .movcf2gr_ (COST_COMPLEX_INSN); array_tune loongarch_cpu_issue_rate = array_tune () .set (CPU_NATIVE, 4) diff --git a/gcc/config/loongarch/loongarch-tune.h b/gcc/config/loongarch/loongarch-tune.h index 4aa01c54c08..7a75c8dd9d9 100644 --- a/gcc/config/loongarch/loongarch-tune.h +++ b/gcc/config/loongarch/loongarch-tune.h @@ -35,6 +35,8 @@ struct loongarch_rtx_cost_data unsigned short int_mult_di; unsigned short int_div_si; unsigned short int_div_di; + unsigned short movcf2gr; + unsigned short movgr2cf; unsigned short branch_cost; unsigned short memory_latency; @@ -95,6 +97,18 @@ struct loongarch_rtx_cost_data return *this; } + loongarch_rtx_cost_data movcf2gr_ (unsigned short _movcf2gr) + { + movcf2gr = _movcf2gr; + return *this; + } + + loongarch_rtx_cost_data movgr2cf_ (unsigned short _movgr2cf) + { + movgr2cf = _movgr2cf; + return *this; + } + loongarch_rtx_cost_data branch_cost_ (unsigned short _branch_cost) { branch_cost = _branch_cost; @@ -106,7 +120,6 @@ struct loongarch_rtx_cost_data memory_latency = _memory_latency; return *this; } - }; /* Costs to use when optimizing for size. */ diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc index 390e3206a17..d7fd203c1ab 100644 --- a/gcc/config/loongarch/loongarch.cc +++ b/gcc/config/loongarch/loongarch.cc @@ -5123,29 +5123,6 @@ loongarch_zero_if_equal (rtx cmp0, rtx cmp1) OPTAB_DIRECT); } -/* Allocate a floating-point condition-code register of mode MODE. */ - -static rtx -loongarch_allocate_fcc (machine_mode mode) -{ - unsigned int regno, count; - - gcc_assert (TARGET_HARD_FLOAT); - - if (mode == FCCmode) - count = 1; - else - gcc_unreachable (); - - cfun->machine->next_fcc += -cfun->machine->next_fcc & (count - 1); - if (cfun->machine->next_fcc > FCC_REG_LAST - FCC_REG_FIRST) - cfun->machine->next_fcc = 0; - - regno = FCC_REG_FIRST + cfun->machine->next_fcc; - cfun->machine->next_fcc += count; - return gen_rtx_REG (mode, regno); -} - /* Sign- or zero-extend OP0 and OP1 for integer comparisons. */ static void @@ -5260,7 +5237,7 @@ loongarch_emit_float_compare (enum rtx_code *code, rtx *op0, rtx *op1) operands for FCMP.cond.fmt, instead a reversed condition code is required and a test for false. */ *code = NE; - *op0 = loongarch_allocate_fcc (FCCmode); + *op0 = gen_reg_rtx (FCCmode); *op1 = const0_rtx; loongarch_emit_binary (cmp_code, *op0, cmp_op0, cmp_op1); @@ -6630,7 +6607,7 @@ loongarch_hard_regno_mode_ok_uncached (unsigned int regno, machine_mode mode) enum mode_class mclass; if (mode == FCCmode) - return FCC_REG_P (regno); + return FCC_REG_P (regno) || GP_REG_P (regno) || FP_REG_P (regno); size = GET_MODE_SIZE (mode); mclass = GET_MODE_CLASS (mode); @@ -6845,6 +6822,9 @@ loongarch_move_to_gpr_cost (reg_class_t from) /* MOVFR2GR, etc. */ return 4; + case FCC_REGS: + return loongarch_cost->movcf2gr; + default: return 0; } @@ -6867,6 +6847,9 @@ loongarch_move_from_gpr_cost (reg_class_t to) /* MOVGR2FR, etc. */ return 4; + case FCC_REGS: + return loongarch_cost->movgr2cf; + default: return 0; } @@ -6901,6 +6884,10 @@ loongarch_register_move_cost (machine_mode mode, reg_class_t from, if (to == dregs) return loongarch_move_to_gpr_cost (from); + /* fcc -> fcc, fcc -> fpr, or fpr -> fcc. */ + if (from == FCC_REGS || to == FCC_REGS) + return COSTS_N_INSNS (from == to ? 2 : 1); + /* Handles cases that require a GPR temporary. */ cost1 = loongarch_move_to_gpr_cost (from); if (cost1 != 0) @@ -6937,6 +6924,39 @@ loongarch_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x, regno = true_regnum (x); + if (mode == FCCmode) + { + if (reg_class_subset_p (rclass, FCC_REGS) && !FP_REG_P (regno)) + { + if (FCC_REG_P (regno)) + return FP_REGS; + + auto fn = in_p ? loongarch_move_from_gpr_cost + : loongarch_move_to_gpr_cost; + + if (fn (FCC_REGS) > fn (FP_REGS) + COSTS_N_INSNS (1)) + return FP_REGS; + + return GP_REG_P (regno) ? NO_REGS : GR_REGS; + } + + if (reg_class_subset_p (rclass, GR_REGS) && FCC_REG_P (regno)) + { + auto fn = in_p ? loongarch_move_to_gpr_cost + : loongarch_move_from_gpr_cost; + + if (fn (FCC_REGS) > fn (FP_REGS) + COSTS_N_INSNS (1)) + return FP_REGS; + + return NO_REGS; + } + + if (reg_class_subset_p (rclass, FP_REGS) && MEM_P (x)) + return GR_REGS; + + return NO_REGS; + } + if (reg_class_subset_p (rclass, FP_REGS)) { if (regno < 0 diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md index 404a663c1a6..c7058282a21 100644 --- a/gcc/config/loongarch/loongarch.md +++ b/gcc/config/loongarch/loongarch.md @@ -2283,11 +2283,72 @@ (define_expand "move_doubleword_fpr" ;; Clear one FCC register -(define_insn "movfcc" - [(set (match_operand:FCC 0 "register_operand" "=z") - (const_int 0))] +(define_expand "movfcc" + [(set (match_operand:FCC 0 "") + (match_operand:FCC 1 ""))] + "TARGET_HARD_FLOAT" +{ + if (memory_operand (operands[0], FCCmode) + && memory_operand (operands[1], FCCmode)) + operands[1] = force_reg (FCCmode, operands[1]); +}) + +(define_insn "movfcc_internal" + [(set (match_operand:FCC 0 "nonimmediate_operand" + "=z,z,*f,*f,*r,*r,*m,*f,*r,z,*r") + (match_operand:FCC 1 "reg_or_0_operand" + "J,*f,z,*f,J*r,*m,J*r,J*r,*f,*r,z"))] + "TARGET_HARD_FLOAT" + "@ + fcmp.caf.s\t%0,$f0,$f0 + movfr2cf\t%0,%1 + movcf2fr\t%0,%1 + fmov.s\t%0,%1 + or\t%0,%z1,$r0 + ld.b\t%0,%1 + st.b\t%z1,%0 + movgr2fr.w\t%0,%1 + movfr2gr.s\t%0,%1 + movgr2cf\t%0,%1 + movcf2gr\t%0,%1" + [(set_attr "type" "move") + (set_attr "mode" "FCC")]) + +(define_insn "fcc_to_" + [(set (match_operand:X 0 "register_operand" "=r") + (if_then_else:X (ne (match_operand:FCC 1 "register_operand" "0") + (const_int 0)) + (const_int 1) + (const_int 0)))] + "TARGET_HARD_FLOAT" "" - "fcmp.caf.s\t%0,$f0,$f0") + [(set_attr "length" "0") + (set_attr "type" "ghost")]) + +(define_expand "cstore4" + [(set (match_operand:SI 0 "register_operand") + (match_operator:SI 1 "loongarch_fcmp_operator" + [(match_operand:ANYF 2 "register_operand") + (match_operand:ANYF 3 "register_operand")]))] + "" + { + rtx fcc = gen_reg_rtx (FCCmode); + rtx cmp = gen_rtx_fmt_ee (GET_CODE (operands[1]), FCCmode, + operands[2], operands[3]); + + emit_insn (gen_rtx_SET (fcc, cmp)); + if (TARGET_64BIT) + { + rtx gpr = gen_reg_rtx (DImode); + emit_insn (gen_fcc_to_di (gpr, fcc)); + emit_insn (gen_rtx_SET (operands[0], + lowpart_subreg (SImode, gpr, DImode))); + } + else + emit_insn (gen_fcc_to_si (operands[0], fcc)); + + DONE; + }) ;; Conditional move instructions. diff --git a/gcc/config/loongarch/predicates.md b/gcc/config/loongarch/predicates.md index 9e9ce58cb53..83fea08315c 100644 --- a/gcc/config/loongarch/predicates.md +++ b/gcc/config/loongarch/predicates.md @@ -590,6 +590,10 @@ (define_predicate "order_operator" (define_predicate "loongarch_cstore_operator" (match_code "ne,eq,gt,gtu,ge,geu,lt,ltu,le,leu")) +(define_predicate "loongarch_fcmp_operator" + (match_code + "unordered,uneq,unlt,unle,eq,lt,le,ordered,ltgt,ne,ge,gt,unge,ungt")) + (define_predicate "small_data_pattern" (and (match_code "set,parallel,unspec,unspec_volatile,prefetch") (match_test "loongarch_small_data_pattern_p (op)"))) diff --git a/gcc/testsuite/gcc.target/loongarch/movcf2gr-via-fr.c b/gcc/testsuite/gcc.target/loongarch/movcf2gr-via-fr.c new file mode 100644 index 00000000000..23334a3a31f --- /dev/null +++ b/gcc/testsuite/gcc.target/loongarch/movcf2gr-via-fr.c @@ -0,0 +1,10 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=loongarch64 -mtune=la464 -mabi=lp64d" } */ +/* { dg-final { scan-assembler "movcf2fr\t\\\$f\[0-9\]+,\\\$fcc" } } */ +/* { dg-final { scan-assembler "movfr2gr\\.s\t\\\$r4" } } */ + +int +t (float a, float b) +{ + return a > b; +} diff --git a/gcc/testsuite/gcc.target/loongarch/movcf2gr.c b/gcc/testsuite/gcc.target/loongarch/movcf2gr.c new file mode 100644 index 00000000000..d27c393b5ed --- /dev/null +++ b/gcc/testsuite/gcc.target/loongarch/movcf2gr.c @@ -0,0 +1,9 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=loongarch64 -mtune=la664 -mabi=lp64d" } */ +/* { dg-final { scan-assembler "movcf2gr\t\\\$r4,\\\$fcc" } } */ + +int +t (float a, float b) +{ + return a > b; +}