From patchwork Thu May 11 10:29:54 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Robin Dapp X-Patchwork-Id: 92475 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b0ea:0:b0:3b6:4342:cba0 with SMTP id b10csp4260692vqo; Thu, 11 May 2023 03:30:43 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ4rtv/egAYHLFD5V5kfyFJOXAzMSJvklrKQgSp7iedl/oywFtfZah6ywfBQ/wNX0s1WuZhR X-Received: by 2002:a17:907:a46:b0:94f:2b80:f3b4 with SMTP id be6-20020a1709070a4600b0094f2b80f3b4mr16665567ejc.69.1683801043670; Thu, 11 May 2023 03:30:43 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1683801043; cv=none; d=google.com; s=arc-20160816; b=Bo0zymwtECS6ZGED9T7XI1ugrVH8W7lpsxWOxq0B4VBwNeeDUz+v82Kq6d2KoZsL1z cUpmYOGzZUA+z2K//53ZM+7ojicyv3JMXNNixKKyi4Zn47K7CnkDSdWlpkSNtj1hZIv0 4q4/ljJYSi46a6OZN0iDMDYsr23l4xnrDhPryuEawsq67l+j8M/enswgcJQC7vMJlHXq oEDYgI9dumWWaOyK7YxtGzhPpYFIkbrFRyaQvLvCCx++ICH0awLR3ojK5L2GOT9XEAju gjrXMEXWeg7c0EW6Hwn/yZaY3PJKKOAeWMmohpxOUZHrMH4KbNwrJUg2wmVcOH06F+GM Xeow== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-transfer-encoding:in-reply-to:references:cc:to :content-language:subject:user-agent:mime-version:date:message-id :dmarc-filter:delivered-to:dkim-signature:dkim-filter; bh=SbmOfDuRl1A6kTesCx9HqAl2gWpIhFRv5eatG4+ijB4=; b=atykciyW0EtDZrXWTmOnsvCNS5IQ/srpZ3Ei2jfrgFbOc/MJJsvPpDzXA64jw29udk Ufak2AO+hTTCb0fpycFfsRSSbsiQ+AQm9tfTuIBJiSaowsw3IL8ANHbhfkx8qN/5rnzN nhq96JpcybHY2tbdSpfMwrS+Xnwn2OEwYrgufz98Xv7chfWQN0pJju9w9PK6+OrjK7vD wdxS31JLIvtvR7oVW5W9BHboRu42TELODzbijz0ylBTr8J11tGF/WQjLruqYWYkV6r4C MThEQ4r5AQYOK5WCm7+kdf5EQXdEZkwnfB8dVnHWiBiIKu5i4ro1UiRxWLTbw27t5vgr 7E6A== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=O7g9AfQX; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from sourceware.org (server2.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id j26-20020a170906831a00b009655fcff588si5575199ejx.835.2023.05.11.03.30.43 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 May 2023 03:30:43 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) client-ip=8.43.85.97; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=O7g9AfQX; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 7D0DE3858C83 for ; Thu, 11 May 2023 10:30:42 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 7D0DE3858C83 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1683801042; bh=SbmOfDuRl1A6kTesCx9HqAl2gWpIhFRv5eatG4+ijB4=; h=Date:Subject:To:Cc:References:In-Reply-To:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=O7g9AfQXiwaXGRHn7TfjFwDLRxvwsIf0PFav/cRdtaH1tAXD7BAEOr4pS0DWPuJUy o9u0Trh14p1AkV/AfFJ92nYzCEd9LHJCs/QgRZcDhKg9Fvj/fU93AKJZJah5f93deS b6X8xza+MabOPQtJ4Lw/9TAfDOyZ2u/ac1l9aT+M= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-ej1-x629.google.com (mail-ej1-x629.google.com [IPv6:2a00:1450:4864:20::629]) by sourceware.org (Postfix) with ESMTPS id 9275B3858D33 for ; Thu, 11 May 2023 10:29:57 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 9275B3858D33 Received: by mail-ej1-x629.google.com with SMTP id a640c23a62f3a-965ab8ed1c0so1380078066b.2 for ; Thu, 11 May 2023 03:29:57 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1683800996; x=1686392996; h=content-transfer-encoding:in-reply-to:from:references:cc:to :content-language:subject:user-agent:mime-version:date:message-id :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=SbmOfDuRl1A6kTesCx9HqAl2gWpIhFRv5eatG4+ijB4=; b=X1C1LQLBBydQMgRsrsfVhPZNARWE+xS8HNF6kXusm1+cLPhTFN3+On1bY7iBKeZrCW abbd8B2wOS1JTtUj2uE/d1HEziWFfQnZzs6UzsQBWvf3fgzvZhdc7rYVfrWC7ST2jphi WjV7oBhmU3hEr9/2ODMmQyKsv8LruA4JKTDmwel9165AXUrkKDXawh1NXP2WEOd00tf6 b79cA8ZFVQlBopWUvhCNaUspcdShEN/KXtVlXFkwoUVfAvcv25P6T1zWl/FwjY8z0h3A tbQ4pwl9gAA/P6S843hYp3ub+L7NyGkUimhMSSvKu6Xtf+3OuPFCeyoDGvokrwKS9lCK NtsQ== X-Gm-Message-State: AC+VfDwL2pPmZKQxD7DAOrr/xT/S90HxB1q+pv1/mG8IIF5M4mYhLH5y l2foiytLKFt00gxVODxCtzQ= X-Received: by 2002:a17:907:72d6:b0:94e:43ce:95f6 with SMTP id du22-20020a17090772d600b0094e43ce95f6mr20610987ejc.47.1683800995922; Thu, 11 May 2023 03:29:55 -0700 (PDT) Received: from [192.168.1.23] (ip-046-005-130-086.um12.pools.vodafone-ip.de. [46.5.130.86]) by smtp.gmail.com with ESMTPSA id mh25-20020a170906eb9900b00882f9130eafsm3743399ejb.26.2023.05.11.03.29.55 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 11 May 2023 03:29:55 -0700 (PDT) Message-ID: Date: Thu, 11 May 2023 12:29:54 +0200 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.10.0 Subject: [PATCH v2] RISC-V: Clarify vlmax and length handling. Content-Language: en-US To: Kito Cheng , Palmer Dabbelt Cc: gcc-patches@gcc.gnu.org, juzhe.zhong@rivai.ai, collison@rivosinc.com, jeffreyalaw@gmail.com References: <55666d64-ec4b-199d-81d5-26c2334606d3@gmail.com> In-Reply-To: X-Spam-Status: No, score=-11.5 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, 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.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Robin Dapp via Gcc-patches From: Robin Dapp Reply-To: Robin Dapp Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org Sender: "Gcc-patches" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1765593363365387831?= X-GMAIL-MSGID: =?utf-8?q?1765593363365387831?= Changes from v1: - Change subject to RISC-V ;) - Minor comment updates and rebasing. This patch tries to improve the wrappers that emit either vlmax or non-vlmax operations. Now, emit_len_op can be used to emit a regular operation. Depending on whether a length != NULL is passed either no VLMAX flags are set or we emit a vsetvli and set VLMAX flags. The patch also adds some comments that describes some of the rationale of the current handling of vlmax/nonvlmax operations. gcc/ChangeLog: * config/riscv/autovec.md: Use renamed functions. * config/riscv/riscv-protos.h (emit_vlmax_op): Rename. (emit_vlmax_reg_op): To this. (emit_nonvlmax_op): Rename. (emit_len_op): To this. (emit_nonvlmax_binop): Rename. (emit_len_binop): To this. * config/riscv/riscv-v.cc (emit_pred_op): Add default parameter. (emit_pred_binop): Remove vlmax_p. (emit_vlmax_op): Rename. (emit_vlmax_reg_op): To this. (emit_nonvlmax_op): Rename. (emit_len_op): To this. (emit_nonvlmax_binop): Rename. (emit_len_binop): To this. (sew64_scalar_helper): Use renamed functions. (expand_tuple_move): Use renamed functions. * config/riscv/riscv.cc (vector_zero_call_used_regs): Use renamed functions. * config/riscv/vector.md: Use renamed functions. --- gcc/config/riscv/autovec.md | 26 ++++----- gcc/config/riscv/riscv-protos.h | 8 +-- gcc/config/riscv/riscv-v.cc | 94 ++++++++++++++++++++------------- gcc/config/riscv/riscv.cc | 4 +- gcc/config/riscv/vector.md | 12 +++-- 5 files changed, 83 insertions(+), 61 deletions(-) diff --git a/gcc/config/riscv/autovec.md b/gcc/config/riscv/autovec.md index e249f4be704..58926ed3e67 100644 --- a/gcc/config/riscv/autovec.md +++ b/gcc/config/riscv/autovec.md @@ -31,8 +31,8 @@ (define_expand "len_load_" (match_operand 3 "const_0_operand")] "TARGET_VECTOR" { - riscv_vector::emit_nonvlmax_op (code_for_pred_mov (mode), operands[0], - operands[1], operands[2], mode); + riscv_vector::emit_len_op (code_for_pred_mov (mode), operands[0], + operands[1], operands[2], mode); DONE; }) @@ -43,8 +43,8 @@ (define_expand "len_store_" (match_operand 3 "const_0_operand")] "TARGET_VECTOR" { - riscv_vector::emit_nonvlmax_op (code_for_pred_mov (mode), operands[0], - operands[1], operands[2], mode); + riscv_vector::emit_len_op (code_for_pred_mov (mode), operands[0], + operands[1], operands[2], mode); DONE; }) @@ -106,16 +106,16 @@ (define_expand "3" { rtx cst; gcc_assert (const_vec_duplicate_p(operands[2], &cst)); - riscv_vector::emit_nonvlmax_binop (code_for_pred_scalar - (, mode), - operands[0], operands[1], cst, - NULL, mode, - mode); + riscv_vector::emit_len_binop (code_for_pred_scalar + (, mode), + operands[0], operands[1], cst, + NULL, mode, + mode); } else - riscv_vector::emit_nonvlmax_binop (code_for_pred - (, mode), - operands[0], operands[1], operands[2], - NULL, mode); + riscv_vector::emit_len_binop (code_for_pred + (, mode), + operands[0], operands[1], operands[2], + NULL, mode); DONE; }) diff --git a/gcc/config/riscv/riscv-protos.h b/gcc/config/riscv/riscv-protos.h index 4d0589e502c..55a43d6270e 100644 --- a/gcc/config/riscv/riscv-protos.h +++ b/gcc/config/riscv/riscv-protos.h @@ -167,10 +167,10 @@ bool legitimize_move (rtx, rtx, machine_mode); void emit_vlmax_vsetvl (machine_mode, rtx); void emit_hard_vlmax_vsetvl (machine_mode, rtx); void emit_vlmax_op (unsigned, rtx, rtx, machine_mode); -void emit_vlmax_op (unsigned, rtx, rtx, rtx, machine_mode); -void emit_nonvlmax_op (unsigned, rtx, rtx, rtx, machine_mode); -void emit_nonvlmax_binop (unsigned, rtx, rtx, rtx, rtx, machine_mode, - machine_mode = VOIDmode); +void emit_vlmax_reg_op (unsigned, rtx, rtx, rtx, machine_mode); +void emit_len_op (unsigned, rtx, rtx, rtx, machine_mode); +void emit_len_binop (unsigned, rtx, rtx, rtx, rtx, machine_mode, + machine_mode = VOIDmode); enum vlmul_type get_vlmul (machine_mode); unsigned int get_ratio (machine_mode); unsigned int get_nf (machine_mode); diff --git a/gcc/config/riscv/riscv-v.cc b/gcc/config/riscv/riscv-v.cc index 8f46226d571..7cf5ec9f3ba 100644 --- a/gcc/config/riscv/riscv-v.cc +++ b/gcc/config/riscv/riscv-v.cc @@ -99,27 +99,24 @@ public: add_vundef_operand (dest_mode); } - void set_len_and_policy (rtx len, bool vlmax_p) + void set_len_and_policy (rtx len, bool force_vlmax = false) { + bool vlmax_p = force_vlmax; gcc_assert (has_dest); - gcc_assert (len || vlmax_p); - if (len) - add_input_operand (len, Pmode); - else + if (!len) { - rtx vlmax = gen_reg_rtx (Pmode); - emit_vlmax_vsetvl (dest_mode, vlmax); - add_input_operand (vlmax, Pmode); + vlmax_p = true; + len = gen_reg_rtx (Pmode); + emit_vlmax_vsetvl (dest_mode, len); } + add_input_operand (len, Pmode); + if (GET_MODE_CLASS (dest_mode) != MODE_VECTOR_BOOL) add_policy_operand (get_prefer_tail_policy (), get_prefer_mask_policy ()); - if (vlmax_p) - add_avl_type_operand (avl_type::VLMAX); - else - add_avl_type_operand (avl_type::NONVLMAX); + add_avl_type_operand (vlmax_p ? avl_type::VLMAX : avl_type::NONVLMAX); } void expand (enum insn_code icode, bool temporary_volatile_p = false) @@ -232,14 +229,14 @@ autovec_use_vlmax_p (void) /* Emit an RVV unmask && vl mov from SRC to DEST. */ static void emit_pred_op (unsigned icode, rtx mask, rtx dest, rtx src, rtx len, - machine_mode mask_mode, bool vlmax_p) + machine_mode mask_mode, bool force_vlmax = false) { insn_expander<8> e; e.set_dest_and_mask (mask, dest, mask_mode); e.add_input_operand (src, GET_MODE (src)); - e.set_len_and_policy (len, vlmax_p); + e.set_len_and_policy (len, force_vlmax); e.expand ((enum insn_code) icode, MEM_P (dest) || MEM_P (src)); } @@ -248,8 +245,8 @@ emit_pred_op (unsigned icode, rtx mask, rtx dest, rtx src, rtx len, specified using SCALAR_MODE. */ static void emit_pred_binop (unsigned icode, rtx mask, rtx dest, rtx src1, rtx src2, - rtx len, machine_mode mask_mode, machine_mode scalar_mode, - bool vlmax_p) + rtx len, machine_mode mask_mode, + machine_mode scalar_mode = VOIDmode) { insn_expander<9> e; e.set_dest_and_mask (mask, dest, mask_mode); @@ -267,37 +264,60 @@ emit_pred_binop (unsigned icode, rtx mask, rtx dest, rtx src1, rtx src2, else e.add_input_operand (src2, scalar_mode); - e.set_len_and_policy (len, vlmax_p); + e.set_len_and_policy (len); e.expand ((enum insn_code) icode, MEM_P (dest) || MEM_P (src1) || MEM_P (src2)); } +/* The RISC-V vsetvli pass uses "known vlmax" operations for optimization. + Whether or not an instruction actually is a vlmax operation is not + recognizable from the length operand alone but the avl_type operand + is used instead. In general, there are two cases: + + - Emit a vlmax operation by passing a NULL length. Here we emit + a vsetvli with vlmax configuration and set the avl_type to VLMAX. + - Emit an operation that uses the existing (last-set) length and + set the avl_type to NONVLMAX. + + Sometimes we also need to set the VLMAX avl_type to an operation that + already uses a given length register. This can happen during or after + register allocation when we are not allowed to create a new register. + For that case we also allow to set the avl_type to VLMAX. +*/ + +/* This function emits a VLMAX vsetvli followed by the actual operation. */ void emit_vlmax_op (unsigned icode, rtx dest, rtx src, machine_mode mask_mode) { - emit_pred_op (icode, NULL_RTX, dest, src, NULL_RTX, mask_mode, true); + emit_pred_op (icode, NULL_RTX, dest, src, NULL_RTX, mask_mode); } +/* This function emits an operation with a given LEN that is determined + by a previously emitted VLMAX vsetvli. */ void -emit_vlmax_op (unsigned icode, rtx dest, rtx src, rtx len, - machine_mode mask_mode) +emit_len_op (unsigned icode, rtx dest, rtx src, rtx len, + machine_mode mask_mode) { - emit_pred_op (icode, NULL_RTX, dest, src, len, mask_mode, true); + emit_pred_op (icode, NULL_RTX, dest, src, len, mask_mode); } +/* This function emits an operation with a given LEN that is known to be + a preceding VLMAX. It also sets the VLMAX flag which allows further + optimization in the vsetvli pass. */ void -emit_nonvlmax_op (unsigned icode, rtx dest, rtx src, rtx len, - machine_mode mask_mode) +emit_vlmax_reg_op (unsigned icode, rtx dest, rtx src, rtx len, + machine_mode mask_mode) { - emit_pred_op (icode, NULL_RTX, dest, src, len, mask_mode, false); + emit_pred_op (icode, NULL_RTX, dest, src, len, mask_mode, + /* Force VLMAX */ true); } void -emit_nonvlmax_binop (unsigned icode, rtx dest, rtx src1, rtx src2, rtx len, - machine_mode mask_mode, machine_mode scalar_mode) +emit_len_binop (unsigned icode, rtx dest, rtx src1, rtx src2, rtx len, + machine_mode mask_mode, machine_mode scalar_mode) { - emit_pred_binop (icode, NULL_RTX, dest, src1, src2, len, mask_mode, - scalar_mode, len ? false : true); + emit_pred_binop (icode, NULL_RTX, dest, src1, src2, len, + mask_mode, scalar_mode); } /* Emit vid.v instruction. */ @@ -345,14 +365,14 @@ expand_vec_series (rtx dest, rtx base, rtx step) int shift = exact_log2 (INTVAL (step)); rtx shift_amount = gen_int_mode (shift, Pmode); insn_code icode = code_for_pred_scalar (ASHIFT, mode); - emit_nonvlmax_binop (icode, step_adj, vid, shift_amount, - NULL, mask_mode, Pmode); + emit_len_binop (icode, step_adj, vid, shift_amount, + NULL, mask_mode, Pmode); } else { insn_code icode = code_for_pred_scalar (MULT, mode); - emit_nonvlmax_binop (icode, step_adj, vid, step, - NULL, mask_mode, inner_mode); + emit_len_binop (icode, step_adj, vid, step, + NULL, mask_mode, inner_mode); } } @@ -367,7 +387,7 @@ expand_vec_series (rtx dest, rtx base, rtx step) { rtx result = gen_reg_rtx (mode); insn_code icode = code_for_pred_scalar (PLUS, mode); - emit_nonvlmax_binop (icode, result, step_adj, base, + emit_len_binop (icode, result, step_adj, base, NULL, mask_mode, inner_mode); emit_move_insn (dest, result); } @@ -739,8 +759,8 @@ sew64_scalar_helper (rtx *operands, rtx *scalar_op, rtx vl, *scalar_op = force_reg (scalar_mode, *scalar_op); rtx tmp = gen_reg_rtx (vector_mode); - riscv_vector::emit_nonvlmax_op (code_for_pred_broadcast (vector_mode), tmp, - *scalar_op, vl, mask_mode); + riscv_vector::emit_len_op (code_for_pred_broadcast (vector_mode), tmp, + *scalar_op, vl, mask_mode); emit_vector_func (operands, tmp); return true; @@ -1046,7 +1066,7 @@ expand_tuple_move (machine_mode mask_mode, rtx *ops) rtx mem = gen_rtx_MEM (subpart_mode, ops[3]); if (fractional_p) - emit_vlmax_op (code_for_pred_mov (subpart_mode), subreg, mem, + emit_vlmax_reg_op (code_for_pred_mov (subpart_mode), subreg, mem, ops[4], mask_mode); else emit_move_insn (subreg, mem); @@ -1068,7 +1088,7 @@ expand_tuple_move (machine_mode mask_mode, rtx *ops) rtx mem = gen_rtx_MEM (subpart_mode, ops[3]); if (fractional_p) - emit_vlmax_op (code_for_pred_mov (subpart_mode), mem, subreg, + emit_vlmax_reg_op (code_for_pred_mov (subpart_mode), mem, subreg, ops[4], mask_mode); else emit_move_insn (mem, subreg); diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index 02d581589ac..cecb4d49092 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -7391,8 +7391,8 @@ vector_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs) emitted_vlmax_vsetvl = true; } - riscv_vector::emit_vlmax_op (code_for_pred_mov (mode), target, - CONST0_RTX (mode), vl, mask_mode); + riscv_vector::emit_vlmax_reg_op (code_for_pred_mov (mode), target, + CONST0_RTX (mode), vl, mask_mode); SET_HARD_REG_BIT (zeroed_hardregs, regno); } diff --git a/gcc/config/riscv/vector.md b/gcc/config/riscv/vector.md index 9ccc0d6a513..75479f27bcd 100644 --- a/gcc/config/riscv/vector.md +++ b/gcc/config/riscv/vector.md @@ -721,8 +721,9 @@ (define_insn_and_split "*mov_lra" else { riscv_vector::emit_vlmax_vsetvl (mode, operands[2]); - riscv_vector::emit_vlmax_op (code_for_pred_mov (mode), - operands[0], operands[1], operands[2], mode); + riscv_vector::emit_vlmax_reg_op (code_for_pred_mov (mode), + operands[0], operands[1], operands[2], + mode); } DONE; }) @@ -741,8 +742,9 @@ (define_insn_and_split "*mov_lra" else { riscv_vector::emit_vlmax_vsetvl (mode, operands[2]); - riscv_vector::emit_vlmax_op (code_for_pred_mov (mode), - operands[0], operands[1], operands[2], mode); + riscv_vector::emit_vlmax_reg_op (code_for_pred_mov (mode), + operands[0], operands[1], operands[2], + mode); } DONE; }) @@ -806,7 +808,7 @@ (define_expand "vec_duplicate" "TARGET_VECTOR" { riscv_vector::emit_vlmax_op (code_for_pred_broadcast (mode), - operands[0], operands[1], mode); + operands[0], operands[1], mode); DONE; } )